Update __init__.py

* dolphin mistral template

* removate trailing \n before attaching the model response

* improve prompt and validator for generated human age

* fix issue where errors during character creation process would not be
communicated to the ux and the character creator would appear stuck

* add dolphin mistral to list

* add talemate_env

* poetry relock

* add json schema for talemate scene files

* fix issues with pydantic after version upgrade

* add json extrac util functions

* fix pydantic model

* use extract json function

* scene generator, better scene name prompt

* OpenHermes-2-Mistral

* alpaca base template
Amethyst 20B template

* character description is no longer part of the sheet and needs to be added separately

* fix pydantic validation

* fix issue where sometimes partial emote strings were kept at the end of dialogue

* no need to commit character name to memory

* dedupe prompts

* clean up extra linebreaks in prompts

* experimental editor agent
agent signals first progress

* take out hardcoded example

* amethyst llm prompt template

* editor agent disableable
agent edit modal tweaks

* world state agent
agent action config schema

* director agent disableable
remove automatic actions config from ux (deprecated)

* fix responsive update when toggling enable on or off in agent dialog

* prompt adjustments
fix divine intellect preset (mirostat values were way off)
fix world state regenerating every turn regardless of setting

* move templates for world state from summarizer to worldstate agent

* conversation agent generation lenght setting

* conversation agent jiggle attribute (randomize offset to certain inference parameters)

* relabel

* scene cover image set to cover as much space as it can

* add character sheet to dialogue example generate prompt

* character creator agent mixin use set_processing

* add <|im_end|> to stopping strings

* add random number gen to template functions

* SynthIA and Tiefighter

* create new persisted characters ouf of world state
natural flow option for conversation agent to help guide multi character conversations

* conversation agent natural flow improvements

* fix bug with 1h time passage option

* some templates

* poetry relock

* fix config validation

* fix issues when detemrining scene history context length to stay within budget

* fixes to world state json parsing
fixes to conversation context length

* remove unused import

* update windows install scripts

* zephyr

* </s> stopping string

* dialog cleanup utils improved

* add agents and clients key to the config example

.gitignore

@@ -1,10 +1,8 @@
-.lmer
 *.pyc
-problems
 *.swp
 *.swo
 *.egg-info
-tales/
 *-internal*
 *.internal*
 *_internal*
+talemate_env

README.md

@@ -4,7 +4,7 @@ Allows you to play roleplay scenarios with large language models.
 
 It does not run any large language models itself but relies on existing APIs. Currently supports **text-generation-webui** and **openai**.
 
-This means you need to either have an openai api key or know how to setup [oobabooga/text-generation-webui](https://github.com/oobabooga/text-generation-webui) (locally or remotely via gpu renting.)
+This means you need to either have an openai api key or know how to setup [oobabooga/text-generation-webui](https://github.com/oobabooga/text-generation-webui) (locally or remotely via gpu renting. `--api` flag needs to be set)
 
 ![Screenshot 1](docs/img/Screenshot_8.png)
 ![Screenshot 2](docs/img/Screenshot_2.png)
@@ -18,15 +18,17 @@ This means you need to either have an openai api key or know how to setup [oobab
     - summarization
     - director
     - creative
-- multi-client (agents can be connected to separate LLMs)
-- long term memory (very experimental at this point)
+- multi-client (agents can be connected to separate APIs)
+- long term memory (experimental)
+    - chromadb integration
+    - passage of time
 - narrative world state
 - narrative tools
 - creative tools 
     - AI backed character creation with template support (jinja2)
     - AI backed scenario creation
 - runpod integration
-- overridable templates foe all LLM prompts. (jinja2)
+- overridable templates for all prompts. (jinja2)
 
 ## Planned features
 
@@ -34,20 +36,27 @@ Kinda making it up as i go along, but i want to lean more into gameplay through
 
 In no particular order:
 
-- Gameplay loop governed by AI
+- Extension support
+    - modular agents and clients
 - Improved world state
 - Dynamic player choice generation
 - Better creative tools
     - node based scenario / character creation
-- Improved long term memory (base is there, but its very rough at the moment)
+- Improved and consistent long term memory
 - Improved director agent
     - Right now this doesn't really work well on anything but GPT-4 (and even there it's debatable). It tends to steer the story in a way that introduces pacing issues. It needs a model that is creative but also reasons really well i think.
+- Gameplay loop governed by AI
+    - objectives
+    - quests
+    - win / lose conditions
 - Automatic1111 client
 
 # Quickstart
 
 ## Installation
 
+Post [here](https://github.com/final-wombat/talemate/issues/17) if you run into problems during installation.
+
 ### Windows
 
 1. Download and install Python 3.10 or higher from the [official Python website](https://www.python.org/downloads/windows/).
@@ -64,7 +73,7 @@ In no particular order:
 1. `git clone git@github.com:final-wombat/talemate`
 1. `cd talemate`
 1. `source install.sh`
-1. Start the backend: `python src/talemate/server/run.py runserver --host 0.0.0.0 --port 5001`.
+1. Start the backend: `python src/talemate/server/run.py runserver --host 0.0.0.0 --port 5050`.
 1. Open a new terminal, navigate to the `talemate_frontend` directory, and start the frontend server by running `npm run serve`.
 
 ## Configuration
@@ -94,26 +103,11 @@ Once the api key is set Pods loaded from text-generation-webui templates (or the
 
 **ATTENTION**: Talemate is not a suitable for way for you to determine whether your pod is currently running or not. **Always** check the runpod dashboard to see if your pod is running or not.
 
-## Recommended Models
+## Recommended Models 
+(as of2023.10.25)
 
-Note: this is my personal opinion while using talemate. If you find a model that works better for you, let me know about it.
-
-Will be updated as i test more models and over time.
-
-| Model Name                    | Type            | Notes                                                                                                             |
-|-------------------------------|-----------------|-------------------------------------------------------------------------------------------------------------------|
-| [GPT-4](https://platform.openai.com/) | Remote         | Still the best for consistency and reasoning, but is heavily censored, while talemate will send a general "decensor" system prompt, depending on the type of content you want to roleplay, there is a chance your key will be banned. **If you do use this make sure to monitor your api usage, talemate tends to send a lot more requests than other roleplaying applications.** |
-| [Nous Hermes LLama2](https://huggingface.co/TheBloke/Nous-Hermes-Llama2-GPTQ) | 13B model | My go-to model for 13B parameters. It's good at roleplay and also smart enough to handle the world state and narrative tools. A 13B model loaded via exllama also allows you run chromadb with the xl instructor embeddings off of a single 4090. |
-| [MythoMax](https://huggingface.co/TheBloke/MythoMax-L2-13B-GPTQ) | 13B model | Similar quality to Hermes LLama2, but a bit more creative. Rarely fails on JSON responses. |
-| [Synthia v1.2 34B](https://huggingface.co/TheBloke/Synthia-34B-v1.2-GPTQ) | 34B model | Cannot be run at full context together with chromadb instructor models on a single 4090. But a great choice if you're running chromadb with the default embeddings (or on cpu). |
-| [Xwin-LM-70B](https://huggingface.co/Xwin-LM/Xwin-LM-70B-V0.1) | 70B model | Great choice if you have the hardware to run it (or can rent it). |
-| [Synthia v1.2 70B](https://huggingface.co/TheBloke/Synthia-70B-v1.2-GPTQ) | 70B model | Great choice if you have the hardware to run it (or can rent it). |
-
-I have not included OpenAI's gpt-3.5-turbo in this list, since it is really inconsistent with JSON responses, plus its probably still just as heavily censored as GPT-4.
-
-I have not tested with Llama 1 models in a while, Lazarus was really good at roleplay, but started failing on JSON requirements.
-
-I have not tested with anything below 13B parameters.
+Any of the top models in any of the size classes here should work well:
+https://www.reddit.com/r/LocalLLaMA/comments/17fhp9k/huge_llm_comparisontest_39_models_tested_7b70b/
 
 ## Connecting to an LLM
 

config.example.yaml

@@ -1,3 +1,5 @@
+agents: {}
+clients: {}
 creator:
   content_context:
   - a fun and engaging slice of life story aimed at an adult audience.

docs/chromadb.md

@@ -1,7 +1,15 @@
-## ChromaDB
+# ChromaDB
+
+Talemate uses ChromaDB to maintain long-term memory. The default embeddings used are really fast but also not incredibly accurate. If you want to use more accurate embeddings you can use the instructor embeddings or the openai embeddings. See below for instructions on how to enable these.
+
+In my testing so far, instructor-xl has proved to be the most accurate (even more-so than openai)
+
+## Local instructor embeddings
 
 If you want chromaDB to use the more accurate (but much slower) instructor embeddings add the following to `config.yaml`:
 
+**Note**: The `xl` model takes a while to load even with cuda. Expect a minute of loading time on the first scene you load.
+
 ```yaml
 chromadb:
     embeddings: instructor
@@ -9,17 +17,23 @@ chromadb:
     instructor_model: hkunlp/instructor-xl
 ```
 
+### Instructor embedding models
+
+- `hkunlp/instructor-base` (smallest / fastest)
+- `hkunlp/instructor-large` 
+- `hkunlp/instructor-xl` (largest / slowest) - requires about 5GB of memory
+
 You will need to restart the backend for this change to take effect.
 
 **NOTE** - The first time you do this it will need to download the instructor model you selected. This may take a while, and the talemate backend will be un-responsive during that time.
 
-Once the download is finished, if talemate is still un-responsive, try reloading the front-end to reconnect. When all fails just restart the backend as well.
+Once the download is finished, if talemate is still un-responsive, try reloading the front-end to reconnect. When all fails just restart the backend as well. I'll try to make this more robust in the future.
 
 ### GPU support
 
 If you want to use the instructor embeddings with GPU support, you will need to install pytorch with CUDA support. 
 
-To do this on windows, run `install-pytorch-cuda.bat` from the project root. Then change your device in the config to `cuda`:
+To do this on windows, run `install-pytorch-cuda.bat` from the project directory. Then change your device in the config to `cuda`:
 
 ```yaml
 chromadb:
@@ -28,8 +42,20 @@ chromadb:
     instructor_model: hkunlp/instructor-xl
 ```
 
-Instructor embedding models:
+## OpenAI embeddings
 
-- `hkunlp/instructor-base` (smallest / fastest)
-- `hkunlp/instructor-large` 
-- `hkunlp/instructor-xl` (largest / slowest) - requires about 5GB of GPU memory
+First make sure your openai key is specified in the `config.yaml` file
+
+```yaml
+openai:
+  api_key: <your-key-here>
+```
+
+Then add the following to `config.yaml` for chromadb:
+
+```yaml
+chromadb:
+    embeddings: openai
+```
+
+**Note**: As with everything openai, using this isn't free. It's way cheaper than their text completion though. ALSO - if you send super explicit content they may flag / ban your key, so keep that in mind (i hear they usually send warnings first though), and always monitor your usage on their dashboard.

docs/linux-install.md

@@ -14,7 +14,7 @@
 
 1. With the virtual environment activated and dependencies installed, you can start the backend server.
 2. Navigate to the `src/talemate/server` directory.
-3. Run the server with `python run.py runserver --host 0.0.0.0 --port 5001`.
+3. Run the server with `python run.py runserver --host 0.0.0.0 --port 5050`.
 
 ### Running the Frontend
 
@@ -22,4 +22,4 @@
 2. If you haven't already, install npm dependencies by running `npm install`.
 3. Start the server with `npm run serve`.
 
-Please note that you may need to set environment variables or modify the host and port as per your setup. You can refer to the `runserver.sh` and `frontend.sh` files for more details.
+Please note that you may need to set environment variables or modify the host and port as per your setup. You can refer to the `runserver.sh` and `frontend.sh` files for more details.

docs/talemate-scene-schema.json

@@ -0,0 +1,187 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "description": {
+      "type": "string"
+    },
+    "intro": {
+      "type": "string"
+    },
+    "name": {
+      "type": "string"
+    },
+    "history": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "message": {
+            "type": "string"
+          },
+          "id": {
+            "type": "integer"
+          },
+          "typ": {
+            "type": "string"
+          },
+          "source": {
+            "type": "string"
+          }
+        },
+        "required": ["message", "id", "typ", "source"]
+      }
+    },
+    "environment": {
+      "type": "string"
+    },
+    "archived_history": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string"
+          },
+          "ts": {
+            "type": "string"
+          }
+        },
+        "required": ["text", "ts"]
+      }
+    },
+    "character_states": {
+      "type": "object"
+    },
+    "characters": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "greeting_text": {
+            "type": "string"
+          },
+          "base_attributes": {
+            "type": "object",
+            "additionalProperties": {
+                "type": "string"
+            }
+          },
+          "details": {
+            "type": "object"
+          },
+          "gender": {
+            "type": "string"
+          },
+          "color": {
+            "type": "string"
+          },
+          "example_dialogue": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "history_events": {
+            "type": "array",
+            "items": {
+              "type": "object"
+            }
+          },
+          "is_player": {
+            "type": "boolean"
+          },
+          "cover_image": {
+            "type": ["string", "null"]
+          }
+        },
+        "required": ["name", "description", "greeting_text", "base_attributes", "details", "gender", "color", "example_dialogue", "history_events", "is_player", "cover_image"]
+      }
+    },
+    "goal": {
+      "type": ["string", "null"]
+    },
+    "goals": {
+      "type": "array",
+      "items": {
+        "type": "object"
+      }
+    },
+    "context": {
+      "type": "string"
+    },
+    "world_state": {
+      "type": "object",
+      "properties": {
+        "characters": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "snapshot": {
+                "type": ["string", "null"]
+              },
+              "emotion": {
+                "type": "string"
+              }
+            },
+            "required": ["snapshot", "emotion"]
+          }
+        },
+        "items": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "snapshot": {
+                "type": ["string", "null"]
+              }
+            },
+            "required": ["snapshot"]
+          }
+        },
+        "location": {
+          "type": ["string", "null"]
+        }
+      },
+      "required": ["characters", "items", "location"]
+    },
+    "assets": {
+      "type": "object",
+      "properties": {
+        "cover_image": {
+          "type": "string"
+        },
+        "assets": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "id": {
+                "type": "string"
+              },
+              "file_type": {
+                "type": "string"
+              },
+              "media_type": {
+                "type": "string"
+              }
+            },
+            "required": ["id", "file_type", "media_type"]
+          }
+        }
+      },
+      "required": ["cover_image", "assets"]
+    },
+    "ts": {
+      "type": "string"
+    }
+  },
+  "required": ["description", "intro", "name", "history", "environment", "archived_history", "character_states", "characters", "context", "world_state", "assets", "ts"]
+}

install.bat

@@ -7,7 +7,7 @@ REM activate the virtual environment
 call talemate_env\Scripts\activate
 
 REM install poetry
-pip install poetry
+python -m pip install poetry "rapidfuzz>=3" -U
 
 REM use poetry to install dependencies
 poetry install

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "talemate"
-version = "0.9.0"
+version = "0.11.1"
 description = "AI-backed roleplay and narrative tools"
 authors = ["FinalWombat"]
 license = "GNU Affero General Public License v3.0"
@@ -27,14 +27,16 @@ typing-inspect = "0.8.0"
 typing_extensions = "^4.5.0"
 uvicorn = "^0.23"
 blinker = "^1.6.2"
-pydantic = "<2"
-langchain = "0.0.213"
+pydantic = "<3"
+langchain = ">0.0.213"
 beautifulsoup4 = "^4.12.2"
 python-dotenv = "^1.0.0"
 websockets = "^11.0.3"
 structlog = "^23.1.0"
 runpod = "==1.2.0"
 nest_asyncio = "^1.5.7"
+isodate = ">=0.6.1"
+thefuzz = ">=0.20.0"
 
 # ChromaDB
 chromadb = ">=0.4,<1"

reinstall.bat

@@ -0,0 +1,18 @@
+@echo off
+
+IF EXIST talemate_env rmdir /s /q "talemate_env"
+
+REM create a virtual environment
+python -m venv talemate_env
+
+REM activate the virtual environment
+call talemate_env\Scripts\activate
+
+REM install poetry
+python -m pip install poetry "rapidfuzz>=3" -U
+
+REM use poetry to install dependencies
+python -m poetry install
+
+echo Virtual environment re-created.
+pause

scenes/infinity-quest/infinity-quest.json

@@ -4,7 +4,29 @@
   "name": "Infinity Quest",
   "history": [],
   "environment": "scene",
-  "archived_history": [],
+  "ts": "P1Y",
+  "archived_history": [
+    {
+      "text": "Captain Elmer and Kaira first met during their rigorous training for the Infinity Quest mission. Their initial interactions were marked by a sense of mutual respect and curiosity.",
+      "ts": "PT1S"
+    },
+    {
+      "text": "Over the course of several months, as they trained together, Elmer and Kaira developed a strong bond. They often spent their free time discussing their dreams of exploring the cosmos.",
+      "ts": "P3M"
+    },
+    {
+      "text": "During a simulated mission, the Starlight Nomad encountered a sudden system malfunction. Elmer and Kaira worked tirelessly together to resolve the issue and avert a potential disaster. This incident strengthened their trust in each other's abilities.",
+      "ts": "P6M"
+    },
+    {
+      "text": "As they ventured further into uncharted space, the crew faced a perilous encounter with a hostile alien species. Elmer and Kaira's coordinated efforts were instrumental in negotiating a peaceful resolution and avoiding conflict.",
+      "ts": "P8M"
+    },
+    {
+      "text": "One memorable evening, while gazing at the stars through the ship's observation deck, Elmer and Kaira shared personal stories from their past. This intimate conversation deepened their connection and understanding of each other.",
+      "ts": "P11M"
+    }
+  ],
   "character_states": {},
   "characters": [
     {

src/talemate/__init__.py

@@ -2,4 +2,4 @@ from .agents import Agent
 from .client import TextGeneratorWebuiClient
 from .tale_mate import *
 
-VERSION = "0.9.0"
+VERSION = "0.11.1"

src/talemate/agents/__init__.py

@@ -6,4 +6,6 @@ from .director import DirectorAgent
 from .memory import ChromaDBMemoryAgent, MemoryAgent
 from .narrator import NarratorAgent
 from .registry import AGENT_CLASSES, get_agent_class, register
-from .summarize import SummarizeAgent
+from .summarize import SummarizeAgent
+from .editor import EditorAgent
+from .world_state import WorldStateAgent

src/talemate/agents/base.py

@@ -10,13 +10,30 @@ from blinker import signal
 import talemate.instance as instance
 import talemate.util as util
 from talemate.emit import emit
-
+import dataclasses
+import pydantic
 
 __all__ = [
     "Agent",
     "set_processing",
 ]
 
+class AgentActionConfig(pydantic.BaseModel):
+    type: str
+    label: str
+    description: str = ""
+    value: Union[int, float, str, bool]
+    max: Union[int, float, None] = None
+    min: Union[int, float, None] = None
+    step: Union[int, float, None] = None
+
+class AgentAction(pydantic.BaseModel):
+    enabled: bool = True
+    label: str
+    description: str = ""
+    config: Union[dict[str, AgentActionConfig], None] = None
+    
+
 def set_processing(fn):
     """
     decorator that emits the agent status as processing while the function
@@ -45,7 +62,6 @@ class Agent(ABC):
 
     agent_type = "agent"
     verbose_name = None
-    
     set_processing = set_processing
 
     @property
@@ -59,18 +75,13 @@ class Agent(ABC):
     def verbose_name(self):
         return self.agent_type.capitalize()
 
-    @classmethod
-    def config_options(cls):
-        return {
-            "client": [name for name, _ in instance.client_instances()],
-        }
+
 
     @property
     def ready(self):
         if not getattr(self.client, "enabled", True):
             return False
         
-        
         if self.client.current_status in ["error", "warning"]:
             return False
         
@@ -79,10 +90,77 @@ class Agent(ABC):
     @property
     def status(self):
         if self.ready:
+            if not self.enabled:
+                return "disabled"
             return "idle" if getattr(self, "processing", 0) == 0 else "busy"
         else:
             return "uninitialized"
 
+    @property
+    def enabled(self):
+        # by default, agents are enabled, an agent class that
+        # is disableable should override this property
+        return True
+    
+    @property
+    def disable(self):
+        # by default, agents are enabled, an agent class that
+        # is disableable should override this property to 
+        # disable the agent
+        pass
+    
+    @property
+    def has_toggle(self):
+        # by default, agents do not have toggles to enable / disable
+        # an agent class that is disableable should override this property
+        return False
+    
+    @property
+    def experimental(self):
+        # by default, agents are not experimental, an agent class that
+        # is experimental should override this property
+        return False
+
+    @classmethod
+    def config_options(cls, agent=None):
+        config_options = {
+            "client": [name for name, _ in instance.client_instances()],
+            "enabled": agent.enabled if agent else True,
+            "has_toggle": agent.has_toggle if agent else False,
+            "experimental": agent.experimental if agent else False,
+        }
+        actions = getattr(agent, "actions", None)
+        
+        if actions:
+            config_options["actions"] = {k: v.model_dump() for k, v in actions.items()}
+        else:
+            config_options["actions"] = {}
+            
+        return config_options
+
+    def apply_config(self, *args, **kwargs):
+        if self.has_toggle and "enabled" in kwargs:
+            self.is_enabled = kwargs.get("enabled", False)
+            
+        if not getattr(self, "actions", None):
+            return
+            
+        for action_key, action in self.actions.items():
+            
+            if not kwargs.get("actions"):
+                continue
+            
+            action.enabled = kwargs.get("actions", {}).get(action_key, {}).get("enabled", False)
+            
+            if not action.config:
+                continue
+            
+            for config_key, config in action.config.items():
+                try:
+                    config.value = kwargs.get("actions", {}).get(action_key, {}).get("config", {}).get(config_key, {}).get("value", config.value)
+                except AttributeError:
+                    pass
+                
     async def emit_status(self, processing: bool = None):
         
         # should keep a count of processing requests, and when the
@@ -101,6 +179,8 @@ class Agent(ABC):
             self.processing += 1
             
         status = "busy" if self.processing > 0 else "idle"
+        if not self.enabled:
+            status = "disabled"
         
         emit(
             "agent_status",
@@ -108,7 +188,7 @@ class Agent(ABC):
             id=self.agent_type,
             status=status,
             details=self.agent_details,
-            data=self.config_options(),
+            data=self.config_options(agent=self),
         )
 
         await asyncio.sleep(0.01)
@@ -159,3 +239,7 @@ class Agent(ABC):
 
                 current_memory_context.append(memory)
         return current_memory_context
+
+@dataclasses.dataclass
+class AgentEmission:
+    agent: Agent

src/talemate/agents/conversation.py

@@ -1,24 +1,38 @@
 from __future__ import annotations
-
+import dataclasses
 import re
+import random
 from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, Union
 
 import talemate.client as client
 import talemate.util as util
 import structlog
 from talemate.emit import emit
+import talemate.emit.async_signals
 from talemate.scene_message import CharacterMessage, DirectorMessage
 from talemate.prompts import Prompt
+from talemate.events import GameLoopEvent
+from talemate.client.context import set_conversation_context_attribute, client_context_attribute, set_client_context_attribute
 
-from .base import Agent, set_processing
+from .base import Agent, AgentEmission, set_processing, AgentAction, AgentActionConfig
 from .registry import register
 
 if TYPE_CHECKING:
-    from talemate.tale_mate import Character, Scene
+    from talemate.tale_mate import Character, Scene, Actor
     
 log = structlog.get_logger("talemate.agents.conversation")
 
+@dataclasses.dataclass
+class ConversationAgentEmission(AgentEmission):
+    actor: Actor
+    character: Character
+    generation: list[str]
+    
+talemate.emit.async_signals.register(
+    "agent.conversation.generated"
+)
+
 @register()
 class ConversationAgent(Agent):
     """
@@ -44,7 +58,223 @@ class ConversationAgent(Agent):
         self.logging_enabled = logging_enabled
         self.logging_date = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
         self.current_memory_context = None
+        
+        # several agents extend this class, but we only want to initialize
+        # these actions for the conversation agent
+        
+        if self.agent_type != "conversation":
+            return
+        
+        self.actions = {
+            "generation_override": AgentAction(
+                enabled = True,
+                label = "Generation Override",
+                description = "Override generation parameters",
+                config = {
+                    "length": AgentActionConfig(
+                        type="number",
+                        label="Generation Length (tokens)",
+                        description="Maximum number of tokens to generate for a conversation response.",
+                        value=96, 
+                        min=32,
+                        max=512,
+                        step=32,
+                    ),
+                    "jiggle": AgentActionConfig(
+                        type="number",
+                        label="Jiggle",
+                        description="If > 0.0 will cause certain generation parameters to have a slight random offset applied to them. The bigger the number, the higher the potential offset.",
+                        value=0.0,
+                        min=0.0,
+                        max=1.0,
+                        step=0.1,
+                    ),
+                }
+            ),
+            "natural_flow": AgentAction(
+                enabled = True,
+                label = "Natural Flow",
+                description = "Will attempt to generate a more natural flow of conversation between multiple characters.",
+                config = {
+                    "max_auto_turns": AgentActionConfig(
+                        type="number",
+                        label="Max. Auto Turns",
+                        description="The maximum number of turns the AI is allowed to generate before it stops and waits for the player to respond.",
+                        value=4, 
+                        min=1,
+                        max=100,
+                        step=1,
+                    ),
+                    "max_idle_turns": AgentActionConfig(
+                        type="number",
+                        label="Max. Idle Turns",
+                        description="The maximum number of turns a character can go without speaking before they are considered overdue to speak.",
+                        value=8, 
+                        min=1,
+                        max=100,
+                        step=1,
+                    ),
+                }
+            ),
+        }
 
+    def connect(self, scene):
+        super().connect(scene)
+        talemate.emit.async_signals.get("game_loop").connect(self.on_game_loop)
+
+    def last_spoken(self):
+        
+        """
+        Returns the last time each character spoke
+        """
+        
+        last_turn = {}
+        turns = 0
+        character_names = self.scene.character_names
+        max_idle_turns = self.actions["natural_flow"].config["max_idle_turns"].value
+        
+        for idx in range(len(self.scene.history) - 1, -1, -1):
+            
+            if isinstance(self.scene.history[idx], CharacterMessage):
+                
+                if turns >= max_idle_turns:
+                    break
+                
+                character = self.scene.history[idx].character_name
+                
+                if character in character_names:
+                    last_turn[character] = turns
+                    character_names.remove(character)
+                    
+                if not character_names:
+                    break
+                
+                turns += 1
+        
+        if character_names and turns >= max_idle_turns:
+            for character in character_names:
+                last_turn[character] = max_idle_turns        
+
+        return last_turn
+        
+    def repeated_speaker(self):
+        """
+        Counts the amount of times the most recent speaker has spoken in a row
+        """
+        character_name = None
+        count = 0
+        for idx in range(len(self.scene.history) - 1, -1, -1):
+            if isinstance(self.scene.history[idx], CharacterMessage):
+                if character_name is None:
+                    character_name = self.scene.history[idx].character_name
+                if self.scene.history[idx].character_name == character_name:
+                    count += 1
+                else:
+                    break
+        return count
+                
+    async def on_game_loop(self, event:GameLoopEvent):
+        await self.apply_natural_flow()
+    
+    async def apply_natural_flow(self):
+        """
+        If the natural flow action is enabled, this will attempt to determine
+        the ideal character to talk next.
+        
+        This will let the AI pick a character to talk to, but if the AI can't figure
+        it out it will apply rules based on max_idle_turns and max_auto_turns.
+        
+        If all fails it will just pick a random character.
+        
+        Repetition is also taken into account, so if a character has spoken twice in a row
+        they will not be picked again until someone else has spoken.
+        """
+        
+        scene = self.scene
+        if self.actions["natural_flow"].enabled and len(scene.character_names) > 2:
+            
+            # last time each character spoke (turns ago)
+            max_idle_turns = self.actions["natural_flow"].config["max_idle_turns"].value
+            max_auto_turns = self.actions["natural_flow"].config["max_auto_turns"].value
+            last_turn = self.last_spoken()
+            last_turn_player = last_turn.get(scene.get_player_character().name, 0)
+            
+            if last_turn_player >= max_auto_turns:
+                self.scene.next_actor = scene.get_player_character().name
+                log.debug("conversation_agent.natural_flow", next_actor="player", overdue=True, player_character=scene.get_player_character().name)
+                return
+            
+            log.debug("conversation_agent.natural_flow", last_turn=last_turn)
+            
+            # determine random character to talk, this will be the fallback in case
+            # the AI can't figure out who should talk next
+            
+            if scene.prev_actor:
+                
+                # we dont want to talk to the same person twice in a row
+                character_names = scene.character_names
+                character_names.remove(scene.prev_actor)
+                random_character_name = random.choice(character_names)
+            else:
+                character_names = scene.character_names                
+                # no one has talked yet, so we just pick a random character
+                
+                random_character_name = random.choice(scene.character_names)
+            
+            overdue_characters = [character for character, turn in last_turn.items() if turn >= max_idle_turns]
+            
+            if overdue_characters and self.scene.history:
+                # Pick a random character from the overdue characters
+                scene.next_actor = random.choice(overdue_characters)
+            elif scene.history:
+                scene.next_actor = None
+                
+                # AI will attempt to figure out who should talk next
+                next_actor = await self.select_talking_actor(character_names)
+                next_actor = next_actor.strip().strip('"').strip(".")
+                
+                for character_name in scene.character_names:
+                    if next_actor.lower() in character_name.lower() or character_name.lower() in next_actor.lower():
+                        scene.next_actor = character_name
+                        break
+                
+                if not scene.next_actor:
+                    # AI couldn't figure out who should talk next, so we just pick a random character
+                    log.debug("conversation_agent.natural_flow", next_actor="random", random_character_name=random_character_name)
+                    scene.next_actor = random_character_name
+                else:
+                    log.debug("conversation_agent.natural_flow", next_actor="picked", ai_next_actor=scene.next_actor)
+            else:
+                # always start with main character (TODO: configurable?)
+                player_character = scene.get_player_character()
+                log.debug("conversation_agent.natural_flow", next_actor="main_character", main_character=player_character)
+                scene.next_actor = player_character.name if player_character else random_character_name
+                
+            scene.log.debug("conversation_agent.natural_flow", next_actor=scene.next_actor)
+
+            
+            # same character cannot go thrice in a row, if this is happening, pick a random character that
+            # isnt the same as the last character
+            
+            if self.repeated_speaker() >= 2 and self.scene.prev_actor == self.scene.next_actor:
+                scene.next_actor = random.choice([c for c in scene.character_names if c != scene.prev_actor])
+                scene.log.debug("conversation_agent.natural_flow", next_actor="random (repeated safeguard)", random_character_name=scene.next_actor)
+            
+        else:
+            scene.next_actor = None
+
+    
+    @set_processing
+    async def select_talking_actor(self, character_names: list[str]=None):
+        result = await Prompt.request("conversation.select-talking-actor", self.client, "conversation_select_talking_actor", vars={
+            "scene": self.scene,
+            "max_tokens": self.client.max_token_length,
+            "character_names": character_names or self.scene.character_names,
+            "character_names_formatted": ", ".join(character_names or self.scene.character_names),
+        })
+        
+        return result
+        
 
     async def build_prompt_default(
         self,
@@ -158,31 +388,30 @@ class ConversationAgent(Agent):
 
     def clean_result(self, result, character):
         
-        
-        log.debug("clean result", result=result)
-        
         if "#" in result:
             result = result.split("#")[0]
         
-        result = result.replace("\n", "__LINEBREAK__").strip()
-
-        # Removes partial sentence at the end
-        result = re.sub(r"[^\.\?\!\*]+(\n|$)", "", result)
-        
         result = result.replace(" :", ":")
-        result = result.strip().strip('"').strip()
         result = result.replace("[", "*").replace("]", "*")
+        result = result.replace("(", "*").replace(")", "*")
         result = result.replace("**", "*")
-        
-        result = result.replace("__LINEBREAK__", "\n")
-
-        # if there is an uneven number of '*' add one to the end
-
-        if result.count("*") % 2 == 1:
-            result += "*"
 
         return result
 
+    def set_generation_overrides(self):
+        if not self.actions["generation_override"].enabled:
+            return
+        
+        set_conversation_context_attribute("length", self.actions["generation_override"].config["length"].value)
+            
+        if self.actions["generation_override"].config["jiggle"].value > 0.0:
+            nuke_repetition = client_context_attribute("nuke_repetition")
+            if nuke_repetition == 0.0:
+                # we only apply the agent override if some other mechanism isn't already
+                # setting the nuke_repetition value
+                nuke_repetition = self.actions["generation_override"].config["jiggle"].value
+                set_client_context_attribute("nuke_repetition", nuke_repetition)
+
     @set_processing
     async def converse(self, actor, editor=None):
         """
@@ -193,6 +422,8 @@ class ConversationAgent(Agent):
         self.current_memory_context = None
 
         character = actor.character
+        
+        self.set_generation_overrides()
 
         result = await self.client.send_prompt(await self.build_prompt(character))
 
@@ -237,7 +468,10 @@ class ConversationAgent(Agent):
         total_result = total_result.split("#")[0]
 
         # Removes partial sentence at the end
-        total_result = re.sub(r"[^\.\?\!\*]+(\n|$)", "", total_result)
+        total_result = util.clean_dialogue(total_result, main_name=character.name)
+        
+        # Remove "{character.name}:" - all occurences
+        total_result = total_result.replace(f"{character.name}:", "")
 
         if total_result.count("*") % 2 == 1:
             total_result += "*"
@@ -257,13 +491,15 @@ class ConversationAgent(Agent):
         )
 
         response_message = util.parse_messages_from_str(total_result, [character.name])
+        
+        log.info("conversation agent", result=response_message)
+            
+        emission = ConversationAgentEmission(agent=self, generation=response_message, actor=actor, character=character)
+        await talemate.emit.async_signals.get("agent.conversation.generated").send(emission)
 
-        if editor:
-            response_message = [
-                editor.help_edit(character, message) for message in response_message
-            ]
+        #log.info("conversation agent", generation=emission.generation)
 
-        messages = [CharacterMessage(message) for message in response_message]
+        messages = [CharacterMessage(message) for message in emission.generation]
 
         # Add message and response to conversation history
         actor.scene.push_history(messages)

src/talemate/agents/creator/__init__.py

@@ -3,15 +3,16 @@ from __future__ import annotations
 import json
 import os
 
-from talemate.agents.conversation import ConversationAgent
+from talemate.agents.base import Agent
 from talemate.agents.registry import register
 from talemate.emit import emit
+import talemate.client as client
 
 from .character import CharacterCreatorMixin
 from .scenario import ScenarioCreatorMixin
 
 @register()
-class CreatorAgent(CharacterCreatorMixin, ScenarioCreatorMixin, ConversationAgent):
+class CreatorAgent(CharacterCreatorMixin, ScenarioCreatorMixin, Agent):
     
     """
     Creates characters and scenarios and other fun stuff!
@@ -20,6 +21,13 @@ class CreatorAgent(CharacterCreatorMixin, ScenarioCreatorMixin, ConversationAgen
     agent_type = "creator"
     verbose_name = "Creator"
 
+    def __init__(
+        self,
+        client: client.TaleMateClient,
+        **kwargs,
+    ):
+        self.client = client
+
     def clean_result(self, result):
         if "#" in result:
             result = result.split("#")[0]

src/talemate/agents/creator/character.py

@@ -9,6 +9,8 @@ from typing import TYPE_CHECKING, Callable
 import talemate.util as util
 from talemate.emit import emit
 from talemate.prompts import Prompt, LoopedPrompt
+from talemate.exceptions import LLMAccuracyError
+from talemate.agents.base import set_processing
 
 if TYPE_CHECKING:
     from talemate.tale_mate import Character
@@ -19,7 +21,11 @@ def validate(k,v):
     if k and k.lower() == "gender":
         return v.lower().strip()
     if k and k.lower() == "age":
-        return int(v.strip())
+        try:
+            return int(v.split("\n")[0].strip())
+        except (ValueError, TypeError):
+            raise LLMAccuracyError("Was unable to get a valid age from the response", model_name=None)
+            
     return v.strip().strip("\n")
 
 DEFAULT_CONTENT_CONTEXT="a fun and engaging adventure aimed at an adult audience."
@@ -31,6 +37,7 @@ class CharacterCreatorMixin:
     
     ## NEW
     
+    @set_processing
     async def create_character_attributes(
         self,
         character_prompt: str,
@@ -42,60 +49,55 @@ class CharacterCreatorMixin:
         predefined_attributes: dict[str, str] = dict(),
     ):
         
-        try:
-            await self.emit_status(processing=True)
-            
-            def spice(prompt, spices):
-                # generate number from 0 to 1 and if its smaller than use_spice
-                # select a random spice from the list and return it formatted
-                # in the prompt
-                if random.random() < use_spice:
-                    spice = random.choice(spices)
-                    return prompt.format(spice=spice)
-                return ""    
-            
-            # drop any empty attributes from predefined_attributes
-            
-            predefined_attributes = {k:v for k,v in predefined_attributes.items() if v}
-            
-            prompt = Prompt.get(f"creator.character-attributes-{template}", vars={
-                "character_prompt": character_prompt,
-                "template": template,
-                "spice": spice,
-                "content_context": content_context,
-                "custom_attributes": custom_attributes,
-                "character_sheet": LoopedPrompt(
-                    validate_value=validate,
-                    on_update=attribute_callback,
-                    generated=predefined_attributes,
-                ),
-            })
-            await prompt.loop(self.client, "character_sheet", kind="create_concise")
-            
-            return prompt.vars["character_sheet"].generated
         
-        finally:
-            await self.emit_status(processing=False)
+        def spice(prompt, spices):
+            # generate number from 0 to 1 and if its smaller than use_spice
+            # select a random spice from the list and return it formatted
+            # in the prompt
+            if random.random() < use_spice:
+                spice = random.choice(spices)
+                return prompt.format(spice=spice)
+            return ""    
+        
+        # drop any empty attributes from predefined_attributes
+        
+        predefined_attributes = {k:v for k,v in predefined_attributes.items() if v}
+        
+        prompt = Prompt.get(f"creator.character-attributes-{template}", vars={
+            "character_prompt": character_prompt,
+            "template": template,
+            "spice": spice,
+            "content_context": content_context,
+            "custom_attributes": custom_attributes,
+            "character_sheet": LoopedPrompt(
+                validate_value=validate,
+                on_update=attribute_callback,
+                generated=predefined_attributes,
+            ),
+        })
+        await prompt.loop(self.client, "character_sheet", kind="create_concise")
+        
+        return prompt.vars["character_sheet"].generated
+        
     
     
+    @set_processing
     async def create_character_description(
         self, 
         character:Character, 
         content_context: str = DEFAULT_CONTENT_CONTEXT,
     ):
         
-        try:
-            await self.emit_status(processing=True)
-            description = await Prompt.request(f"creator.character-description", self.client, "create", vars={
-                "character": character,
-                "content_context": content_context,
-            })
-            
-            return description.strip()
-        finally:
-            await self.emit_status(processing=False)
+        description = await Prompt.request(f"creator.character-description", self.client, "create", vars={
+            "character": character,
+            "content_context": content_context,
+        })
+        
+        return description.strip()
+
         
     
+    @set_processing
     async def create_character_details(
         self, 
         character: Character,
@@ -104,23 +106,21 @@ class CharacterCreatorMixin:
         questions: list[str] = None,
         content_context: str = DEFAULT_CONTENT_CONTEXT,
     ):
-        try:
-            await self.emit_status(processing=True)
-            prompt = Prompt.get(f"creator.character-details-{template}", vars={
-                "character_details": LoopedPrompt(
-                    validate_value=validate,
-                    on_update=detail_callback,
-                ),
-                "template": template,
-                "content_context": content_context,
-                "character": character,
-                "custom_questions": questions or [],
-            })
-            await prompt.loop(self.client, "character_details", kind="create_concise")
-            return prompt.vars["character_details"].generated
-        finally:
-            await self.emit_status(processing=False)
+        prompt = Prompt.get(f"creator.character-details-{template}", vars={
+            "character_details": LoopedPrompt(
+                validate_value=validate,
+                on_update=detail_callback,
+            ),
+            "template": template,
+            "content_context": content_context,
+            "character": character,
+            "custom_questions": questions or [],
+        })
+        await prompt.loop(self.client, "character_details", kind="create_concise")
+        return prompt.vars["character_details"].generated
+
     
+    @set_processing
     async def create_character_example_dialogue(
         self,
         character: Character,
@@ -132,64 +132,86 @@ class CharacterCreatorMixin:
         rules_callback: Callable = lambda rules: None,
     ):
         
-        try:
-            await self.emit_status(processing=True)
+        dialogue_rules = await Prompt.request(f"creator.character-dialogue-rules", self.client, "create", vars={
+            "guide": guide,
+            "character": character,
+            "examples": examples or [],
+            "content_context": content_context,
+        })
         
-            dialogue_rules = await Prompt.request(f"creator.character-dialogue-rules", self.client, "create", vars={
-                "guide": guide,
-                "character": character,
-                "examples": examples or [],
-                "content_context": content_context,
-            })
+        log.info("dialogue_rules", dialogue_rules=dialogue_rules)
+        
+        if rules_callback:
+            rules_callback(dialogue_rules)
             
-            log.info("dialogue_rules", dialogue_rules=dialogue_rules)
-            
-            if rules_callback:
-                rules_callback(dialogue_rules)
-                
-            example_dialogue_prompt = Prompt.get(f"creator.character-example-dialogue-{template}", vars={
-                "guide": guide,
-                "character": character,
-                "examples": examples or [],
-                "content_context": content_context,
-                "dialogue_rules": dialogue_rules,
-                "generated_examples": LoopedPrompt(
-                    validate_value=validate,
-                    on_update=example_callback,
-                ),
-            })
-            
-            await example_dialogue_prompt.loop(self.client, "generated_examples", kind="create")
-            
-            return example_dialogue_prompt.vars["generated_examples"].generated
-        finally:
-            await self.emit_status(processing=False)
+        example_dialogue_prompt = Prompt.get(f"creator.character-example-dialogue-{template}", vars={
+            "guide": guide,
+            "character": character,
+            "examples": examples or [],
+            "content_context": content_context,
+            "dialogue_rules": dialogue_rules,
+            "generated_examples": LoopedPrompt(
+                validate_value=validate,
+                on_update=example_callback,
+            ),
+        })
+        
+        await example_dialogue_prompt.loop(self.client, "generated_examples", kind="create")
+        
+        return example_dialogue_prompt.vars["generated_examples"].generated
+
             
             
+    @set_processing
     async def determine_content_context_for_character(
         self,
         character: Character,
     ):
         
-        try:
-            await self.emit_status(processing=True)
-            content_context = await Prompt.request(f"creator.determine-content-context", self.client, "create", vars={
-                "character": character,
-            })
-            return content_context.strip()
-        finally:
-            await self.emit_status(processing=False)
+        content_context = await Prompt.request(f"creator.determine-content-context", self.client, "create", vars={
+            "character": character,
+        })
+        return content_context.strip()
+
             
+    @set_processing
     async def determine_character_attributes(
         self,
         character: Character,
     ):
         
-        try:
-            await self.emit_status(processing=True)
-            attributes = await Prompt.request(f"creator.determine-character-attributes", self.client, "analyze_long", vars={
-                "character": character,
-            })
-            return attributes
-        finally:
-            await self.emit_status(processing=False)
+        attributes = await Prompt.request(f"creator.determine-character-attributes", self.client, "analyze_long", vars={
+            "character": character,
+        })
+        return attributes
+    
+    @set_processing
+    async def determine_character_description(
+        self,
+        character: Character,
+        text:str=""
+    ):
+        
+        description = await Prompt.request(f"creator.determine-character-description", self.client, "create", vars={
+            "character": character,
+            "scene": self.scene,
+            "text": text,
+            "max_tokens": self.client.max_token_length,
+        })
+        return description.strip()
+    
+    @set_processing
+    async def generate_character_from_text(
+        self,
+        text: str,
+        template: str,
+        content_context: str = DEFAULT_CONTENT_CONTEXT,
+    ):
+        
+        base_attributes = await self.create_character_attributes(
+            character_prompt=text,
+            template=template,
+            content_context=content_context,
+        )
+        
+        

src/talemate/agents/creator/scenario.py

@@ -3,6 +3,7 @@ import re
 import random
 
 from talemate.prompts import Prompt
+from talemate.agents.base import set_processing
 
 class ScenarioCreatorMixin:
     
@@ -10,8 +11,7 @@ class ScenarioCreatorMixin:
     Adds scenario creation functionality to the creator agent
     """
     
-    ### NEW
-    
+    @set_processing
     async def create_scene_description(
         self,
         prompt:str,
@@ -29,27 +29,23 @@ class ScenarioCreatorMixin:
             
             callback (callable): A callback to call when the scene has been created.
         """
-        try:
-            await self.emit_status(processing=True)
-            scene = self.scene
+        scene = self.scene
+        
+        description = await Prompt.request(
+            "creator.scenario-description",
+            self.client,
+            "create",
+            vars={
+                "prompt": prompt,
+                "content_context": content_context,
+                "max_tokens": self.client.max_token_length,
+                "scene": scene,
+            }
+        )
+        description = description.strip()
+        
+        return description
             
-            description = await Prompt.request(
-                "creator.scenario-description",
-                self.client,
-                "create",
-                vars={
-                    "prompt": prompt,
-                    "content_context": content_context,
-                    "max_tokens": self.client.max_token_length,
-                    "scene": scene,
-                }
-            )
-            description = description.strip()
-            
-            return description
-            
-        finally:
-            await self.emit_status(processing=False)
     
     
     async def create_scene_name(
@@ -70,27 +66,21 @@ class ScenarioCreatorMixin:
                 
                 description (str): The description of the scene.
             """
-            try:
-                await self.emit_status(processing=True)
-                
-                scene = self.scene
-                
-                name = await Prompt.request(
-                    "creator.scenario-name",
-                    self.client,
-                    "create",
-                    vars={
-                        "prompt": prompt,
-                        "content_context": content_context,
-                        "description": description,
-                        "scene": scene,
-                    }
-                )
-                name = name.strip().strip('.!').replace('"','')
-                return name
-                
-            finally:
-                await self.emit_status(processing=False)
+            scene = self.scene
+            
+            name = await Prompt.request(
+                "creator.scenario-name",
+                self.client,
+                "create",
+                vars={
+                    "prompt": prompt,
+                    "content_context": content_context,
+                    "description": description,
+                    "scene": scene,
+                }
+            )
+            name = name.strip().strip('.!').replace('"','')
+            return name
     
     
     async def create_scene_intro(
@@ -114,25 +104,30 @@ class ScenarioCreatorMixin:
             
             name (str): The name of the scene.
         """
-        try:
-            await self.emit_status(processing=True)
-            
-            scene = self.scene
-            
-            intro = await Prompt.request(
-                "creator.scenario-intro",
-                self.client,
-                "create",
-                vars={
-                    "prompt": prompt,
-                    "content_context": content_context,
-                    "description": description,
-                    "name": name,
-                    "scene": scene,
-                }
-            )
-            intro = intro.strip()
-            return intro
-            
-        finally:
-            await self.emit_status(processing=False)
+        
+        scene = self.scene
+        
+        intro = await Prompt.request(
+            "creator.scenario-intro",
+            self.client,
+            "create",
+            vars={
+                "prompt": prompt,
+                "content_context": content_context,
+                "description": description,
+                "name": name,
+                "scene": scene,
+            }
+        )
+        intro = intro.strip()
+        return intro
+    
+    @set_processing
+    async def determine_scenario_description(
+        self,
+        text:str
+    ):
+        description = await Prompt.request(f"creator.determine-scenario-description", self.client, "analyze_long", vars={
+            "text": text,
+        })
+        return description

src/talemate/agents/director.py

@@ -12,9 +12,8 @@ from talemate.prompts import Prompt
 from talemate.scene_message import NarratorMessage, DirectorMessage
 from talemate.automated_action import AutomatedAction
 import talemate.automated_action as automated_action
-from .conversation import ConversationAgent
 from .registry import register
-from .base import set_processing
+from .base import set_processing, AgentAction, AgentActionConfig, Agent
 
 if TYPE_CHECKING:
     from talemate import Actor, Character, Player, Scene
@@ -22,10 +21,31 @@ if TYPE_CHECKING:
 log = structlog.get_logger("talemate")
 
 @register()
-class DirectorAgent(ConversationAgent):
+class DirectorAgent(Agent):
     agent_type = "director"
     verbose_name = "Director"
     
+    def __init__(self, client, **kwargs):
+        self.is_enabled = True
+        self.client = client
+        self.actions = {
+            "direct": AgentAction(enabled=False, label="Direct", description="Will attempt to direct the scene. Runs automatically after AI dialogue (n turns).", config={
+                "turns": AgentActionConfig(type="number", label="Turns", description="Number of turns to wait before directing the sceen", value=10, min=1, max=100, step=1)
+            }),
+        }
+        
+    @property
+    def enabled(self):
+        return self.is_enabled
+    
+    @property
+    def has_toggle(self):
+        return True
+        
+    @property
+    def experimental(self):
+        return True
+    
     def get_base_prompt(self, character: Character, budget:int):
         return [character.description, character.base_attributes.get("scenario_context", "")] + self.scene.context_history(budget=budget, keep_director=False)
 
@@ -338,34 +358,4 @@ class DirectorAgent(ConversationAgent):
         else:
             goal_met = True
         
-        return goal_met
-    
-    
-@automated_action.register("director", frequency=4, call_initially=True, enabled=False)
-class AutomatedDirector(automated_action.AutomatedAction):
-    """
-    Runs director.direct actions every n turns
-    """
-
-    async def action(self):
-        scene = self.scene
-        director = scene.get_helper("director")
-        
-        if not scene.active_actor or scene.active_actor.character.is_player:
-            return False
-        
-        if not director:
-            return
-        
-        director_response = await director.agent.direct(scene.active_actor.character)
-    
-        if director_response is True:
-            # director directed different agent, nothing to do
-            return
-    
-        if not director_response:
-            return
-        
-        director_message = DirectorMessage(director_response, source=scene.active_actor.character.name)
-        emit("director", director_message, character=scene.active_actor.character)
-        scene.push_history(director_message)
+        return goal_met

src/talemate/agents/editor.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import asyncio
+import traceback
+from typing import TYPE_CHECKING, Callable, List, Optional, Union
+
+import talemate.data_objects as data_objects
+import talemate.util as util
+import talemate.emit.async_signals
+from talemate.prompts import Prompt
+from talemate.scene_message import DirectorMessage, TimePassageMessage
+
+from .base import Agent, set_processing, AgentAction
+from .registry import register
+
+import structlog
+
+import time
+import re
+
+if TYPE_CHECKING:
+    from talemate.tale_mate import Actor, Character, Scene
+    from talemate.agents.conversation import ConversationAgentEmission
+
+log = structlog.get_logger("talemate.agents.editor")
+
+@register()
+class EditorAgent(Agent):
+    """
+    Editor agent
+
+    will attempt to improve the quality of dialogue
+    """
+
+    agent_type = "editor"
+    verbose_name = "Editor"
+    
+    def __init__(self, client, **kwargs):
+        self.client = client
+        self.is_enabled = True
+        self.actions = {
+            "edit_dialogue": AgentAction(enabled=False, label="Edit dialogue", description="Will attempt to improve the quality of dialogue based on the character and scene. Runs automatically after each AI dialogue."),
+            "fix_exposition": AgentAction(enabled=True, label="Fix exposition", description="Will attempt to fix exposition and emotes, making sure they are displayed in italics. Runs automatically after each AI dialogue."),
+            "add_detail": AgentAction(enabled=False, label="Add detail", description="Will attempt to add extra detail and exposition to the dialogue. Runs automatically after each AI dialogue.")
+        }
+        
+    @property
+    def enabled(self):
+        return self.is_enabled
+    
+    @property
+    def has_toggle(self):
+        return True
+        
+    @property
+    def experimental(self):
+        return True
+
+    def connect(self, scene):
+        super().connect(scene)
+        talemate.emit.async_signals.get("agent.conversation.generated").connect(self.on_conversation_generated)
+        
+    async def on_conversation_generated(self, emission:ConversationAgentEmission):
+        """
+        Called when a conversation is generated
+        """
+        
+        if not self.enabled:
+            return
+        
+        log.info("editing conversation", emission=emission)
+        
+        edited = []
+        for text in emission.generation:
+
+            
+            edit = await self.add_detail(
+                text,
+                emission.character
+            )
+            
+            edit = await self.edit_conversation(
+                edit,
+                emission.character
+            )
+            
+            edit = await self.fix_exposition(
+                edit,
+                emission.character
+            )
+            
+            edited.append(edit)
+            
+        emission.generation = edited
+        
+        
+    @set_processing
+    async def edit_conversation(self, content:str, character:Character):
+        """
+        Edits a conversation
+        """
+        
+        if not self.actions["edit_dialogue"].enabled:
+            return content
+        
+        response = await Prompt.request("editor.edit-dialogue", self.client, "edit_dialogue", vars={
+            "content": content,
+            "character": character,
+            "scene": self.scene,
+            "max_length": self.client.max_token_length
+        })
+        
+        response = response.split("[end]")[0]
+        
+        response = util.replace_exposition_markers(response)
+        response = util.clean_dialogue(response, main_name=character.name)        
+        response = util.strip_partial_sentences(response)
+        
+        return response
+        
+    @set_processing
+    async def fix_exposition(self, content:str, character:Character):
+        """
+        Edits a text to make sure all narrative exposition and emotes is encased in *
+        """
+        
+        if not self.actions["fix_exposition"].enabled:
+            return content
+        
+        #response = await Prompt.request("editor.fix-exposition", self.client, "edit_fix_exposition", vars={
+        #    "content": content,
+        #    "character": character,
+        #    "scene": self.scene,
+        #    "max_length": self.client.max_token_length
+        #})
+        
+        content = util.clean_dialogue(content, main_name=character.name)        
+        content = util.strip_partial_sentences(content)
+        content = util.ensure_dialog_format(content, talking_character=character.name)
+        
+        return content
+    
+    @set_processing
+    async def add_detail(self, content:str, character:Character):
+        """
+        Edits a text to increase its length and add extra detail and exposition
+        """
+        
+        if not self.actions["add_detail"].enabled:
+            return content
+        
+        response = await Prompt.request("editor.add-detail", self.client, "edit_add_detail", vars={
+            "content": content,
+            "character": character,
+            "scene": self.scene,
+            "max_length": self.client.max_token_length
+        })
+        
+        response = util.replace_exposition_markers(response)
+        response = util.clean_dialogue(response, main_name=character.name)        
+        response = util.strip_partial_sentences(response)
+        
+        return response

src/talemate/agents/memory.py

@@ -35,7 +35,7 @@ class MemoryAgent(Agent):
     verbose_name = "Long-term memory"
 
     @classmethod
-    def config_options(cls):
+    def config_options(cls, agent=None):
         return {}
 
     def __init__(self, scene, **kwargs):
@@ -50,14 +50,13 @@ class MemoryAgent(Agent):
     def close_db(self):
         raise NotImplementedError()
 
-    async def add(self, text, character=None, uid=None):
+    async def add(self, text, character=None, uid=None, ts:str=None, **kwargs):
         if not text:
             return
 
-        log.debug("memory add", text=text, character=character, uid=uid)
-        await self._add(text, character=character, uid=uid)
+        await self._add(text, character=character, uid=uid, ts=ts, **kwargs)
 
-    async def _add(self, text, character=None):
+    async def _add(self, text, character=None, ts:str=None, **kwargs):
         raise NotImplementedError()
 
     async def add_many(self, objects: list[dict]):
@@ -79,7 +78,7 @@ class MemoryAgent(Agent):
         return self.db.get(id)
 
     def on_archive_add(self, event: events.ArchiveEvent):
-        asyncio.ensure_future(self.add(event.text, uid=event.memory_id))
+        asyncio.ensure_future(self.add(event.text, uid=event.memory_id, ts=event.ts, typ="history"))
 
     def on_character_state(self, event: events.CharacterStateEvent):
         asyncio.ensure_future(
@@ -256,7 +255,7 @@ class ChromaDBMemoryAgent(MemoryAgent):
 
         self.db_client = chromadb.Client(Settings(anonymized_telemetry=False))
 
-        openai_key = self.config.get("openai").get("api_key") or os.environ.get("OPENAI_API_KEY"),
+        openai_key = self.config.get("openai").get("api_key") or os.environ.get("OPENAI_API_KEY")
 
         if openai_key and self.USE_OPENAI:
             log.info(
@@ -300,25 +299,35 @@ class ChromaDBMemoryAgent(MemoryAgent):
         except ValueError:
             pass
 
-    async def _add(self, text, character=None, uid=None):
+    async def _add(self, text, character=None, uid=None, ts:str=None, **kwargs):
         metadatas = []
         ids = []
 
         await self.emit_status(processing=True)
 
         if character:
-            metadatas.append({"character": character.name, "source": "talemate"})
+            meta = {"character": character.name, "source": "talemate"}
+            if ts:
+                meta["ts"] = ts
+            meta.update(kwargs)
+            metadatas.append(meta)
             self.memory_tracker.setdefault(character.name, 0)
             self.memory_tracker[character.name] += 1
             id = uid or f"{character.name}-{self.memory_tracker[character.name]}"
             ids = [id]
         else:
-            metadatas.append({"character": "__narrator__", "source": "talemate"})
+            meta = {"character": "__narrator__", "source": "talemate"}
+            if ts:
+                meta["ts"] = ts
+            meta.update(kwargs)
+            metadatas.append(meta)
             self.memory_tracker.setdefault("__narrator__", 0)
             self.memory_tracker["__narrator__"] += 1
             id = uid or f"__narrator__-{self.memory_tracker['__narrator__']}"
             ids = [id]
 
+        log.debug("chromadb agent add", text=text, meta=meta, id=id)
+
         self.db.upsert(documents=[text], metadatas=metadatas, ids=ids)
 
         await self.emit_status(processing=False)
@@ -341,7 +350,6 @@ class ChromaDBMemoryAgent(MemoryAgent):
             metadatas.append(meta)
             uid = obj.get("id", f"{character}-{self.memory_tracker[character]}")
             ids.append(uid)
-
         self.db.upsert(documents=documents, metadatas=metadatas, ids=ids)
 
         await self.emit_status(processing=False)
@@ -371,14 +379,27 @@ class ChromaDBMemoryAgent(MemoryAgent):
         #log.debug("crhomadb agent get", text=text, where=where)
 
         _results = self.db.query(query_texts=[text], where=where)
-
+        
         results = []
 
         for i in range(len(_results["distances"][0])):
-            await asyncio.sleep(0.001)
             distance = _results["distances"][0][i]
+            
+            doc = _results["documents"][0][i]
+            meta = _results["metadatas"][0][i]
+            ts = meta.get("ts")
+            
             if distance < 1:
-                results.append(_results["documents"][0][i])
+                
+                try:
+                    date_prefix = util.iso8601_diff_to_human(ts, self.scene.ts)
+                except Exception:
+                    log.error("chromadb agent", error="failed to get date prefix", ts=ts, scene_ts=self.scene.ts)
+                    date_prefix = None
+                    
+                if date_prefix:
+                    doc = f"{date_prefix}: {doc}"
+                results.append(doc)
             else:
                 break
 

src/talemate/agents/narrator.py

@@ -7,20 +7,27 @@ from typing import TYPE_CHECKING, Callable, List, Optional, Union
 import talemate.util as util
 from talemate.emit import wait_for_input
 from talemate.prompts import Prompt
-from talemate.agents.base import set_processing
+from talemate.agents.base import set_processing, Agent
+import talemate.client as client
 
-from .conversation import ConversationAgent
 from .registry import register
 
-
-
-
 @register()
-class NarratorAgent(ConversationAgent):
+class NarratorAgent(Agent):
     agent_type = "narrator"
     verbose_name = "Narrator"
-
+    
+    def __init__(
+        self,
+        client: client.TaleMateClient,
+        **kwargs,
+    ):
+        self.client = client
+        
     def clean_result(self, result):
+        
+        result = result.strip().strip(":").strip()
+        
         if "#" in result:
             result = result.split("#")[0]
         

src/talemate/agents/summarize.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import asyncio
+import traceback
 from typing import TYPE_CHECKING, Callable, List, Optional, Union
 
 import talemate.data_objects as data_objects
 import talemate.util as util
 from talemate.prompts import Prompt
-from talemate.scene_message import DirectorMessage
+from talemate.scene_message import DirectorMessage, TimePassageMessage
 
 from .base import Agent, set_processing
 from .registry import register
@@ -14,6 +15,7 @@ from .registry import register
 import structlog
 
 import time
+import re
 
 log = structlog.get_logger("talemate.agents.summarize")
 
@@ -40,6 +42,16 @@ class SummarizeAgent(Agent):
         super().connect(scene)
         scene.signals["history_add"].connect(self.on_history_add)
 
+    def clean_result(self, result):
+        if "#" in result:
+            result = result.split("#")[0]
+
+        # Removes partial sentence at the end
+        result = re.sub(r"[^\.\?\!]+(\n|$)", "", result)
+        result = result.strip()
+
+        return result
+
     @set_processing
     async def build_archive(self, scene):
         end = None
@@ -49,16 +61,36 @@ class SummarizeAgent(Agent):
             recent_entry = None
         else:
             recent_entry = scene.archived_history[-1]
-            start = recent_entry["end"] + 1
+            start = recent_entry.get("end", 0) + 1
 
-        token_threshold = 1300
+        token_threshold = 1500
         tokens = 0
         dialogue_entries = []
+        ts = "PT0S"
+        time_passage_termination = False
+        
+        if recent_entry:
+            ts = recent_entry.get("ts", ts)
+        
         for i in range(start, len(scene.history)):
             dialogue = scene.history[i]
             if isinstance(dialogue, DirectorMessage):
+                if i == start:
+                    start += 1
                 continue
             
+            if isinstance(dialogue, TimePassageMessage):
+                log.debug("build_archive", time_passage_message=dialogue)
+                if i == start:
+                    ts = util.iso8601_add(ts, dialogue.ts)
+                    log.debug("build_archive", time_passage_message=dialogue, start=start, i=i, ts=ts)
+                    start += 1
+                    continue
+                log.debug("build_archive", time_passage_message_termination=dialogue)
+                time_passage_termination = True
+                end = i - 1
+                break
+            
             tokens += util.count_tokens(dialogue)
             dialogue_entries.append(dialogue)
             if tokens > token_threshold:  #
@@ -68,49 +100,65 @@ class SummarizeAgent(Agent):
         if end is None:
             # nothing to archive yet
             return
+        
+        log.debug("build_archive", start=start, end=end, ts=ts, time_passage_termination=time_passage_termination)
 
         extra_context = None
         if recent_entry:
             extra_context = recent_entry["text"]
+            
+        # in order to summarize coherently, we need to determine if there is a favorable
+        # cutoff point (e.g., the scene naturally ends or shifts meaninfully in the middle
+        # of the  dialogue)
+        #
+        # One way to do this is to check if the last line is a TimePassageMessage, which
+        # indicates a scene change or a significant pause. 
+        # 
+        # If not, we can ask the AI to find a good point of
+        # termination.
+        
+        if not time_passage_termination:
+            
+            # No TimePassageMessage, so we need to ask the AI to find a good point of termination
+            
+            terminating_line = await self.analyze_dialoge(dialogue_entries)
 
-        terminating_line = await self.analyze_dialoge(dialogue_entries)
+            if terminating_line:
+                adjusted_dialogue = []
+                for line in dialogue_entries:                    
+                    if str(line) in terminating_line:
+                        break
+                    adjusted_dialogue.append(line)
+                dialogue_entries = adjusted_dialogue
+                end = start + len(dialogue_entries)
+            
+        if dialogue_entries:
+            summarized = await self.summarize(
+                "\n".join(map(str, dialogue_entries)), extra_context=extra_context
+            )
+        
+        else:
+            # AI has likely identified the first line as a scene change, so we can't summarize
+            # just use the first line
+            summarized = str(scene.history[start])
 
-        log.debug("summarize agent build archive", terminating_line=terminating_line)
+        # determine the appropariate timestamp for the summarization
 
-        if terminating_line:
-            adjusted_dialogue = []
-            for line in dialogue_entries:                    
-                if str(line) in terminating_line:
-                    break
-                adjusted_dialogue.append(line)
-            dialogue_entries = adjusted_dialogue
-            end = start + len(dialogue_entries)
-
-        summarized = await self.summarize(
-            "\n".join(map(str, dialogue_entries)), extra_context=extra_context
-        )
-
-        scene.push_archive(data_objects.ArchiveEntry(summarized, start, end))
+        scene.push_archive(data_objects.ArchiveEntry(summarized, start, end, ts=ts))
 
         return True
 
     @set_processing
     async def analyze_dialoge(self, dialogue):
-        instruction = "Examine the dialogue from the beginning and find the first line that marks a scene change. Repeat the line back to me exactly as it is written"
-
-        prepare_response = "The first line that marks a scene change is: "
-
-        prompt = dialogue + ["", instruction, f"<|BOT|>{prepare_response}"]
-
-        response = await self.client.send_prompt("\n".join(map(str, prompt)), kind="summarize")
-
-        if prepare_response in response:
-            response = response.replace(prepare_response, "")
-
+        response = await Prompt.request("summarizer.analyze-dialogue", self.client, "analyze_freeform", vars={
+            "dialogue": "\n".join(map(str, dialogue)),
+            "scene": self.scene,
+            "max_tokens": self.client.max_token_length,
+        })
+        
         response = self.clean_result(response)
-
         return response
-
+        
     @set_processing
     async def summarize(
         self,
@@ -129,7 +177,7 @@ class SummarizeAgent(Agent):
             "max_tokens": self.client.max_token_length,
         })
         
-        self.scene.log.info("summarize", dialogue=text, response=response)
+        self.scene.log.info("summarize", dialogue_length=len(text), summarized_length=len(response))
 
         return self.clean_result(response)
 
@@ -150,49 +198,7 @@ class SummarizeAgent(Agent):
         return response
 
 
-    @set_processing
-    async def request_world_state(self):
-
-        t1 = time.time()
-
-        _, world_state = await Prompt.request(
-            "summarizer.request-world-state",
-            self.client,
-            "analyze",
-            vars = {
-                "scene": self.scene,
-                "max_tokens": self.client.max_token_length,
-                "object_type": "character",
-                "object_type_plural": "characters",
-            }
-        )
-        
-        self.scene.log.debug("request_world_state", response=world_state, time=time.time() - t1)
-        
-        return world_state
             
             
-    @set_processing
-    async def request_world_state_inline(self):
+    
         
-        """
-        EXPERIMENTAL, Overall the one shot request seems about as coherent as the inline request, but the inline request is is about twice as slow and would need to run on every dialogue line.
-        """
-
-        t1 = time.time()
-
-        # first, we need to get the marked items (objects etc.)
-
-        marked_items_response = await Prompt.request(
-            "summarizer.request-world-state-inline-items",
-            self.client,
-            "analyze_freeform",
-            vars = {
-                "scene": self.scene,
-                "max_tokens": self.client.max_token_length,
-            }
-        )
-        
-        self.scene.log.debug("request_world_state_inline", marked_items=marked_items_response, time=time.time() - t1)
-        
-        return marked_items_response

src/talemate/agents/world_state.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import asyncio
+import traceback
+from typing import TYPE_CHECKING, Callable, List, Optional, Union
+
+import talemate.data_objects as data_objects
+import talemate.emit.async_signals
+import talemate.util as util
+from talemate.prompts import Prompt
+from talemate.scene_message import DirectorMessage, TimePassageMessage
+
+from .base import Agent, set_processing, AgentAction, AgentActionConfig
+from .registry import register
+
+import structlog
+
+import time
+import re
+
+if TYPE_CHECKING:
+    from talemate.agents.conversation import ConversationAgentEmission
+    
+
+log = structlog.get_logger("talemate.agents.world_state")
+
+@register()
+class WorldStateAgent(Agent):
+    """
+    An agent that handles world state related tasks.
+    """
+
+    agent_type = "world_state"
+    verbose_name = "World State"
+
+    def __init__(self, client, **kwargs):
+        self.client = client
+        self.is_enabled = True
+        self.actions = {
+            "update_world_state": AgentAction(enabled=True, label="Update world state", description="Will attempt to update the world state based on the current scene. Runs automatically after AI dialogue (n turns).", config={
+                "turns": AgentActionConfig(type="number", label="Turns", description="Number of turns to wait before updating the world state.", value=5, min=1, max=100, step=1)
+            }),
+        }
+        
+        self.next_update = 0
+        
+    @property
+    def enabled(self):
+        return self.is_enabled
+    
+    @property
+    def has_toggle(self):
+        return True
+        
+    @property
+    def experimental(self):
+        return True
+
+    def connect(self, scene):
+        super().connect(scene)
+        talemate.emit.async_signals.get("agent.conversation.generated").connect(self.on_conversation_generated)
+
+    async def on_conversation_generated(self, emission:ConversationAgentEmission):
+        """
+        Called when a conversation is generated
+        """
+        
+        if not self.enabled:
+            return
+        
+        for _ in emission.generation:
+            await self.update_world_state()
+            
+
+    async def update_world_state(self):
+        if not self.enabled:
+            return
+        
+        if not self.actions["update_world_state"].enabled:
+            return
+        
+        log.debug("update_world_state", next_update=self.next_update, turns=self.actions["update_world_state"].config["turns"].value)
+        
+        scene = self.scene
+        
+        if self.next_update % self.actions["update_world_state"].config["turns"].value != 0 or self.next_update == 0:
+            self.next_update += 1
+            return
+        
+        self.next_update = 0
+        await scene.world_state.request_update()
+        
+
+    @set_processing
+    async def request_world_state(self):
+
+        t1 = time.time()
+
+        _, world_state = await Prompt.request(
+            "world_state.request-world-state",
+            self.client,
+            "analyze_long",
+            vars = {
+                "scene": self.scene,
+                "max_tokens": self.client.max_token_length,
+                "object_type": "character",
+                "object_type_plural": "characters",
+            }
+        )
+        
+        self.scene.log.debug("request_world_state", response=world_state, time=time.time() - t1)
+        
+        return world_state
+
+    @set_processing
+    async def request_world_state_inline(self):
+        
+        """
+        EXPERIMENTAL, Overall the one shot request seems about as coherent as the inline request, but the inline request is is about twice as slow and would need to run on every dialogue line.
+        """
+
+        t1 = time.time()
+
+        # first, we need to get the marked items (objects etc.)
+
+        marked_items_response = await Prompt.request(
+            "world_state.request-world-state-inline-items",
+            self.client,
+            "analyze_freeform",
+            vars = {
+                "scene": self.scene,
+                "max_tokens": self.client.max_token_length,
+            }
+        )
+        
+        self.scene.log.debug("request_world_state_inline", marked_items=marked_items_response, time=time.time() - t1)
+        
+        return marked_items_response
+
+    @set_processing
+    async def analyze_time_passage(
+        self,
+        text: str,
+    ):
+        
+        response = await Prompt.request(
+            "world_state.analyze-time-passage",
+            self.client,
+            "analyze_freeform_short",
+            vars = {
+                "scene": self.scene,
+                "max_tokens": self.client.max_token_length,
+                "text": text,
+            }
+        )
+        
+        duration = response.split("\n")[0].split(" ")[0].strip()
+        
+        if not duration.startswith("P"):
+            duration = "P"+duration
+        
+        return duration
+
+    @set_processing
+    async def analyze_text_and_answer_question(
+        self,
+        text: str,
+        query: str,
+    ):
+        
+        response = await Prompt.request(
+            "world_state.analyze-text-and-answer-question",
+            self.client,
+            "analyze_freeform",
+            vars = {
+                "scene": self.scene,
+                "max_tokens": self.client.max_token_length,
+                "text": text,
+                "query": query,
+            }
+        )
+        
+        log.debug("analyze_text_and_answer_question", query=query, text=text, response=response)
+        
+        return response
+    
+    @set_processing
+    async def identify_characters(
+        self,
+        text: str = None,
+    ):
+        
+        """
+        Attempts to identify characters in the given text.
+        """
+        
+        _, data = await Prompt.request(
+            "world_state.identify-characters",
+            self.client,
+            "analyze",
+            vars = {
+                "scene": self.scene,
+                "max_tokens": self.client.max_token_length,
+                "text": text,
+            }
+        )
+        
+        log.debug("identify_characters", text=text, data=data)
+        
+        return data
+    
+    @set_processing
+    async def extract_character_sheet(
+        self,
+        name:str,
+        text:str = None,
+    ):
+        
+        """
+        Attempts to extract a character sheet from the given text.
+        """
+        
+        response = await Prompt.request(
+            "world_state.extract-character-sheet",
+            self.client,
+            "analyze_creative",
+            vars = {
+                "scene": self.scene,
+                "max_tokens": self.client.max_token_length,
+                "text": text,
+                "name": name,
+            }
+        )
+        
+        # loop through each line in response and if it contains a : then extract
+        # the left side as an attribute name and the right side as the value
+        #
+        # break as soon as a non-empty line is found that doesn't contain a :
+        
+        data = {}
+        for line in response.split("\n"):
+            if not line.strip():
+                continue
+            if not ":" in line:
+                break
+            name, value = line.split(":", 1)
+            data[name.strip()] = value.strip()
+        
+        return data

src/talemate/client/context.py

@@ -4,6 +4,9 @@ Context managers for various client-side operations.
 
 from contextvars import ContextVar
 from pydantic import BaseModel, Field
+from copy import deepcopy
+
+import structlog
 
 __all__ = [
     'context_data',
@@ -11,6 +14,14 @@ __all__ = [
     'ContextModel',
 ]
 
+log = structlog.get_logger()
+
+def model_to_dict_without_defaults(model_instance):
+    model_dict = model_instance.dict()
+    for field_name, field in model_instance.__class__.__fields__.items():
+        if field.default == model_dict.get(field_name):
+            del model_dict[field_name]
+    return model_dict
 
 class ConversationContext(BaseModel):
     talking_character: str = None
@@ -22,9 +33,10 @@ class ContextModel(BaseModel):
     """
     nuke_repetition: float = Field(0.0, ge=0.0, le=3.0)
     conversation: ConversationContext = Field(default_factory=ConversationContext)
+    length: int = 96
 
 # Define the context variable as an empty dictionary
-context_data = ContextVar('context_data', default=ContextModel().dict())
+context_data = ContextVar('context_data', default=ContextModel().model_dump())
 
 def client_context_attribute(name, default=None):
     """
@@ -35,7 +47,23 @@ def client_context_attribute(name, default=None):
     # Return the value of the key if it exists, otherwise return the default value
     return data.get(name, default)
 
-
+def set_client_context_attribute(name, value):
+    """
+    Set the value of the context variable `context_data` for the given key.
+    """
+    # Get the current context data
+    data = context_data.get()
+    # Set the value of the key
+    data[name] = value
+    
+def set_conversation_context_attribute(name, value):
+    """
+    Set the value of the context variable `context_data.conversation` for the given key.
+    """
+    # Get the current context data
+    data = context_data.get()
+    # Set the value of the key
+    data["conversation"][name] = value
 
 class ClientContext:
     """
@@ -47,33 +75,23 @@ class ClientContext:
         Initialize the context manager with the key-value pairs to be set.
         """
         # Validate the data with the Pydantic model
-        self.values = ContextModel(**kwargs).dict()
-        self.tokens = {}
+        self.values = model_to_dict_without_defaults(ContextModel(**kwargs))
 
     def __enter__(self):
         """
         Set the key-value pairs to the context variable `context_data` when entering the context.
         """
         # Get the current context data
-        data = context_data.get()
-        # For each key-value pair, save the current value of the key (if it exists) and set the new value
-        for key, value in self.values.items():
-            self.tokens[key] = data.get(key, None)
-            data[key] = value
+        
+        data = deepcopy(context_data.get()) if context_data.get() else {}
+        data.update(self.values)
+        
         # Update the context data
-        context_data.set(data)
+        self.token = context_data.set(data)
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """
         Reset the context variable `context_data` to its previous values when exiting the context.
         """
-        # Get the current context data
-        data = context_data.get()
-        # For each key, if a previous value exists, reset it. Otherwise, remove the key
-        for key in self.values.keys():
-            if self.tokens[key] is not None:
-                data[key] = self.tokens[key]
-            else:
-                data.pop(key, None)
-        # Update the context data
-        context_data.set(data)
+        
+        context_data.reset(self.token)

src/talemate/client/model_prompts.py

@@ -41,10 +41,15 @@ class ModelPrompt:
         
     def set_response(self, prompt:str, response_str:str):
         
+        prompt = prompt.strip("\n").strip()
+        
         if "<|BOT|>" in prompt:
-            prompt = prompt.replace("<|BOT|>", response_str)
+            if "\n<|BOT|>" in prompt:
+                prompt = prompt.replace("\n<|BOT|>", response_str)
+            else:
+                prompt = prompt.replace("<|BOT|>", response_str)
         else:
-            prompt = prompt + response_str
+            prompt = prompt.rstrip("\n") + response_str
             
         return prompt
 

src/talemate/client/openai.py

@@ -97,15 +97,28 @@ class OpenAIClient:
 
     def get_system_message(self, kind: str) -> str:
        
-       if kind in ["narrate", "story"]:
-           return system_prompts.NARRATOR
-       if kind == "director":
-           return system_prompts.DIRECTOR
-       if kind in ["create", "creator"]:
-           return system_prompts.CREATOR
-       if kind in ["roleplay", "conversation"]:
-           return system_prompts.ROLEPLAY
-       return system_prompts.BASIC
+        if "narrate" in kind:
+            return system_prompts.NARRATOR
+        if "story" in kind:
+            return system_prompts.NARRATOR
+        if "director" in kind:
+            return system_prompts.DIRECTOR
+        if "create" in kind:
+            return system_prompts.CREATOR
+        if "roleplay" in kind:
+            return system_prompts.ROLEPLAY
+        if "conversation" in kind:
+            return system_prompts.ROLEPLAY
+        if "editor" in kind:
+            return system_prompts.EDITOR
+        if "world_state" in kind:
+            return system_prompts.WORLD_STATE
+        if "analyst" in kind:
+            return system_prompts.ANALYST
+        if "analyze" in kind:
+            return system_prompts.ANALYST
+       
+        return system_prompts.BASIC
                   
     async def send_prompt(
         self, prompt: str, kind: str = "conversation", finalize: Callable = lambda x: x

src/talemate/client/system_prompts.py

@@ -10,6 +10,10 @@ CREATOR = str(Prompt.get("creator.system"))
 
 DIRECTOR = str(Prompt.get("director.system"))
 
-ANALYST = str(Prompt.get("summarizer.system-analyst"))
+ANALYST = str(Prompt.get("world_state.system-analyst"))
 
-ANALYST_FREEFORM = str(Prompt.get("summarizer.system-analyst-freeform"))
+ANALYST_FREEFORM = str(Prompt.get("world_state.system-analyst-freeform"))
+
+EDITOR = str(Prompt.get("editor.system"))
+
+WORLD_STATE = str(Prompt.get("world_state.system-analyst"))

src/talemate/client/textgenwebui.py

@@ -94,17 +94,16 @@ PRESET_KOBOLD_GODLIKE = {
     "repetition_penalty_range": 1024,
 }
 
-PRESET_DEVINE_INTELLECT = {
+PRESET_DIVINE_INTELLECT = {
     'temperature': 1.31,
     'top_p': 0.14,
     "repetition_penalty_range": 1024,
     'repetition_penalty': 1.17,
-    #"repetition_penalty": 1.3,
-    #"encoder_repetition_penalty": 1.2,
-    #"no_repeat_ngram_size": 2,
     'top_k': 49,
-    "mirostat_mode": 2,
-    "mirostat_tau": 8,
+    "mirostat_mode": 0,
+    "mirostat_tau": 5,
+    "mirostat_eta": 0.1,
+    "tfs": 1,
 }
 
 PRESET_SIMPLE_1 = {
@@ -114,7 +113,6 @@ PRESET_SIMPLE_1 = {
     "top_k": 20,
 }
 
-
 def jiggle_randomness(prompt_config:dict, offset:float=0.3) -> dict:
     """
     adjusts temperature and repetition_penalty
@@ -405,7 +403,7 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": 75,
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
         }
         config.update(PRESET_TALEMATE_CONVERSATION)
         return config
@@ -425,12 +423,13 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
             f"{character}:" for character in conversation_context["other_characters"]
         ]
         
-        log.debug("prompt_config_conversation", stopping_strings=stopping_strings, conversation_context=conversation_context)
+        max_new_tokens = conversation_context.get("length", 96)
+        log.debug("prompt_config_conversation", stopping_strings=stopping_strings, conversation_context=conversation_context, max_new_tokens=max_new_tokens)
 
         config = {
             "prompt": prompt,
-            "max_new_tokens": 75,
-            "chat_prompt_size": self.max_token_length,
+            "max_new_tokens": max_new_tokens,
+            "truncation_length": self.max_token_length,
             "stopping_strings": stopping_strings,
         }
         config.update(PRESET_TALEMATE_CONVERSATION)
@@ -443,6 +442,13 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = self.prompt_config_conversation(prompt)
         config["max_new_tokens"] = 300
         return config
+    
+    def prompt_config_conversation_select_talking_actor(self, prompt: str) -> dict:
+        config = self.prompt_config_conversation(prompt)
+        config["max_new_tokens"] = 30
+        config["stopping_strings"] += [":"]
+        return config
+
 
     def prompt_config_summarize(self, prompt: str) -> dict:
         prompt = self.prompt_template(
@@ -453,7 +459,7 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": 500,
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
         }
         
         config.update(PRESET_LLAMA_PRECISE)
@@ -468,12 +474,29 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": 500,
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
         }
         
         config.update(PRESET_SIMPLE_1)
         return config
     
+    def prompt_config_analyze_creative(self, prompt: str) -> dict:
+        prompt = self.prompt_template(
+            system_prompts.ANALYST,
+            prompt,
+        )
+
+        config = {}
+        config.update(PRESET_DIVINE_INTELLECT)
+        config.update({
+            "prompt": prompt, 
+            "max_new_tokens": 1024,
+            "repetition_penalty_range": 1024,
+            "truncation_length": self.max_token_length
+        })
+        
+        return config
+    
     def prompt_config_analyze_long(self, prompt: str) -> dict:
         config = self.prompt_config_analyze(prompt)
         config["max_new_tokens"] = 1000
@@ -488,13 +511,18 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": 500,
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
         }
         
-        config.update(PRESET_SIMPLE_1)
+        config.update(PRESET_LLAMA_PRECISE)
         return config
 
 
+    def prompt_config_analyze_freeform_short(self, prompt: str) -> dict:
+        config = self.prompt_config_analyze_freeform(prompt)
+        config["max_new_tokens"] = 10
+        return config
+
     def prompt_config_narrate(self, prompt: str) -> dict:
         prompt = self.prompt_template(
             system_prompts.NARRATOR,
@@ -504,7 +532,7 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": 500,
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
         }
         config.update(PRESET_LLAMA_PRECISE)
         return config
@@ -519,9 +547,9 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
             "prompt": prompt,
             "max_new_tokens": 300,
             "seed": random.randint(0, 1000000000),
-            "chat_prompt_size": self.max_token_length
+            "truncation_length": self.max_token_length
         }
-        config.update(PRESET_DEVINE_INTELLECT)
+        config.update(PRESET_DIVINE_INTELLECT)
         config.update({
             "repetition_penalty": 1.3,
             "repetition_penalty_range": 2048,
@@ -536,7 +564,7 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": min(1024, self.max_token_length * 0.35),
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
         }
         config.update(PRESET_TALEMATE_CREATOR)
         return config
@@ -550,7 +578,7 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": min(400, self.max_token_length * 0.25),
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
             "stopping_strings": ["<|DONE|>", "\n\n"]
         }
         config.update(PRESET_TALEMATE_CREATOR)
@@ -570,7 +598,7 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config = {
             "prompt": prompt,
             "max_new_tokens": min(600, self.max_token_length * 0.25),
-            "chat_prompt_size": self.max_token_length,
+            "truncation_length": self.max_token_length,
         }
         config.update(PRESET_SIMPLE_1)
         return config
@@ -586,6 +614,42 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         config.update(max_new_tokens=2)
         return config
          
+    def prompt_config_edit_dialogue(self, prompt:str) -> dict:
+        prompt = self.prompt_template(
+            system_prompts.EDITOR,
+            prompt,
+        )
+        
+        conversation_context = client_context_attribute("conversation")
+        
+        stopping_strings = [
+            f"{character}:" for character in conversation_context["other_characters"]
+        ]
+        
+        config = {
+            "prompt": prompt,
+            "max_new_tokens": 100,
+            "truncation_length": self.max_token_length,
+            "stopping_strings": stopping_strings,
+        }
+        
+        config.update(PRESET_DIVINE_INTELLECT)
+
+        return config
+
+    def prompt_config_edit_add_detail(self, prompt:str) -> dict:
+        
+        config = self.prompt_config_edit_dialogue(prompt)
+        config.update(max_new_tokens=200)
+        return config
+    
+
+    def prompt_config_edit_fix_exposition(self, prompt:str) -> dict:
+        
+        config = self.prompt_config_edit_dialogue(prompt)
+        config.update(max_new_tokens=1024)
+        return config
+
 
     async def send_prompt(
         self, prompt: str, kind: str = "conversation", finalize: Callable = lambda x: x
@@ -606,7 +670,7 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         fn_prompt_config = getattr(self, f"prompt_config_{kind}")
         fn_url = self.prompt_url
         message = fn_prompt_config(prompt)
-        
+                
         if client_context_attribute("nuke_repetition") > 0.0:
             log.info("nuke repetition", offset=client_context_attribute("nuke_repetition"), temperature=message["temperature"], repetition_penalty=message["repetition_penalty"])
             message = jiggle_randomness(message, offset=client_context_attribute("nuke_repetition"))
@@ -621,6 +685,21 @@ class TextGeneratorWebuiClient(RESTTaleMateClient):
         log.debug("send_prompt",  token_length=token_length, max_token_length=self.max_token_length)
         
         message["prompt"] = message["prompt"].strip()
+        
+        #print(f"prompt: |{message['prompt']}|")
+        
+        # add <|im_end|> to stopping strings
+        if "stopping_strings" in message:
+            message["stopping_strings"] += ["<|im_end|>", "</s>"]
+        else:
+            message["stopping_strings"] = ["<|im_end|>", "</s>"]
+
+        #message["seed"] = -1
+
+        #for k,v in message.items():
+        #    if k == "prompt":
+        #        continue
+        #    print(f"{k}: {v}")
 
         response = await self.send_message(message, fn_url())
 

src/talemate/commands/__init__.py

@@ -22,6 +22,7 @@ from .cmd_save import CmdSave
 from .cmd_save_as import CmdSaveAs
 from .cmd_save_characters import CmdSaveCharacters
 from .cmd_setenv import CmdSetEnvironmentToScene, CmdSetEnvironmentToCreative
+from .cmd_time_util import *
 from .cmd_world_state import CmdWorldState
 from .cmd_run_helios_test import CmdHeliosTest
 from .manager import Manager

src/talemate/commands/cmd_rebuild_archive.py

@@ -20,8 +20,11 @@ class CmdRebuildArchive(TalemateCommand):
         if not summarizer:
             self.system_message("No summarizer found")
             return True
-
-        self.scene.archived_history = []
+        
+        # clear out archived history, but keep pre-established history
+        self.scene.archived_history = [
+            ah for ah in self.scene.archived_history if ah.get("end") is None
+        ]
 
         while True:
             more = await summarizer.agent.build_archive(self.scene)

src/talemate/commands/cmd_time_util.py

@@ -0,0 +1,50 @@
+"""
+Commands to manage scene timescale
+"""
+
+import asyncio
+import logging
+
+from talemate.commands.base import TalemateCommand
+from talemate.commands.manager import register
+from talemate.prompts.base import set_default_sectioning_handler
+from talemate.scene_message import TimePassageMessage
+from talemate.util import iso8601_duration_to_human
+from talemate.emit import wait_for_input, emit
+import isodate
+
+__all__ = [
+    "CmdAdvanceTime",
+]
+
+@register
+class CmdAdvanceTime(TalemateCommand):
+    """
+    Command class for the 'advance_time' command
+    """
+
+    name = "advance_time"
+    description = "Advance the scene time by a given amount (expects iso8601 duration))"
+    aliases = ["time_a"]
+
+    async def run(self):
+        if not self.args:
+            self.emit("system", "You must specify an amount of time to advance")
+            return
+        
+        try:
+            isodate.parse_duration(self.args[0])
+        except isodate.ISO8601Error:
+            self.emit("system", "Invalid duration")
+            return
+        
+        try:
+            msg = self.args[1]
+        except IndexError:
+            msg = iso8601_duration_to_human(self.args[0], suffix=" later")
+                
+        message = TimePassageMessage(ts=self.args[0], message=msg)
+        emit('time', message)
+        
+        self.scene.push_history(message)
+        self.scene.emit_status()

src/talemate/commands/cmd_world_state.py

@@ -1,9 +1,12 @@
 import asyncio
+import random
 
 from talemate.commands.base import TalemateCommand
 from talemate.commands.manager import register
 from talemate.util import colored_text, wrap_text
 from talemate.scene_message import NarratorMessage
+from talemate.emit import wait_for_input
+import talemate.instance as instance
 
 
 @register
@@ -24,4 +27,63 @@ class CmdWorldState(TalemateCommand):
             await self.scene.world_state.request_update_inline()
             return True
         await self.scene.world_state.request_update()
-    
+
+@register
+class CmdPersistCharacter(TalemateCommand):
+    
+    """
+    Will attempt to create an actual character from a currently non
+    tracked character in the scene, by name.
+    
+    Once persisted this character can then participate in the scene.
+    """
+    
+    name = "persist_character"
+    description = "Persist a character by name"
+    aliases = ["pc"]
+    
+    async def run(self):
+        from talemate.tale_mate import Character, Actor
+        
+        scene = self.scene
+        world_state = instance.get_agent("world_state")
+        creator = instance.get_agent("creator")
+        
+        if not len(self.args):
+            characters = await world_state.identify_characters()
+            available_names = [character["name"] for character in characters.get("characters") if not scene.get_character(character["name"])]
+            
+            if not len(available_names):
+                raise ValueError("No characters available to persist.")
+            
+            name = await wait_for_input("Which character would you like to persist?", data={
+                "input_type": "select",
+                "choices": available_names,
+                "multi_select": False,  
+            })
+        else:
+            name = self.args[0]
+            
+        scene.log.debug("persist_character", name=name)
+        
+        character = Character(name=name)
+        character.color = random.choice(['#F08080', '#FFD700', '#90EE90', '#ADD8E6', '#DDA0DD', '#FFB6C1', '#FAFAD2', '#D3D3D3', '#B0E0E6', '#FFDEAD'])
+        
+        attributes = await world_state.extract_character_sheet(name=name)
+        scene.log.debug("persist_character", attributes=attributes)
+        
+        character.base_attributes = attributes
+        
+        description = await creator.determine_character_description(character)
+        
+        character.description = description
+        
+        scene.log.debug("persist_character", description=description)
+        
+        actor = Actor(character=character, agent=instance.get_agent("conversation"))
+        
+        await scene.add_actor(actor)
+        
+        self.emit("system", f"Added character {name} to the scene.")
+        
+        scene.emit_status()

src/talemate/config.py

@@ -4,26 +4,42 @@ import structlog
 import os
 
 from pydantic import BaseModel
-from typing import Optional, Dict
+from typing import Optional, Dict, Union
 
 log = structlog.get_logger("talemate.config")
 
 class Client(BaseModel):
     type: str
     name: str
-    model: Optional[str]
-    api_url: Optional[str]
-    max_token_length: Optional[int]
+    model: Union[str,None] = None
+    api_url: Union[str,None] = None
+    max_token_length: Union[int,None] = None
     
     class Config:
         extra = "ignore"
+ 
+
+class AgentActionConfig(BaseModel):
+    value: Union[int, float, str, bool]
+        
+class AgentAction(BaseModel):
+    enabled: bool = True
+    config: Union[dict[str, AgentActionConfig], None] = None
 
 class Agent(BaseModel):
-    name: str
-    client: str = None
+    name: Union[str,None] = None
+    client: Union[str,None] = None
+    actions: Union[dict[str, AgentAction], None] = None
+    enabled: bool = True
     
     class Config:
         extra = "ignore"
+        
+    # change serialization so actions and enabled are only
+    # serialized if they are not None
+    
+    def model_dump(self, **kwargs):
+        return super().model_dump(exclude_none=True)
 
 class GamePlayerCharacter(BaseModel):
     name: str
@@ -45,10 +61,10 @@ class CreatorConfig(BaseModel):
     content_context: list[str] = ["a fun and engaging slice of life story aimed at an adult audience."]
 
 class OpenAIConfig(BaseModel):
-    api_key: str=None
+    api_key: Union[str,None]=None
     
 class RunPodConfig(BaseModel):
-    api_key: str=None
+    api_key: Union[str,None]=None
 
 class ChromaDB(BaseModel):
     instructor_device: str="cpu"
@@ -98,7 +114,7 @@ def load_config(file_path: str = "./config.yaml") -> dict:
         log.error("config validation", error=e)
         return None
 
-    return config.dict()
+    return config.model_dump()
 
 
 def save_config(config, file_path: str = "./config.yaml"):
@@ -110,11 +126,11 @@ def save_config(config, file_path: str = "./config.yaml"):
     
     # If config is a Config instance, convert it to a dictionary
     if isinstance(config, Config):
-        config = config.dict()
+        config = config.model_dump(exclude_none=True)
     elif isinstance(config, dict):
         # validate
         try:
-            config = Config(**config).dict()
+            config = Config(**config).model_dump(exclude_none=True)
         except pydantic.ValidationError as e:
             log.error("config validation", error=e)
             return None

src/talemate/data_objects.py

@@ -1,8 +1,12 @@
 from dataclasses import dataclass
 
+__all__ = [
+    "ArchiveEntry",
+]
 
 @dataclass
 class ArchiveEntry:
     text: str
-    start: int
-    end: int
+    start: int = None
+    end: int = None
+    ts: str = None

src/talemate/emit/async_signals.py

@@ -0,0 +1,57 @@
+handlers = {
+}
+
+class AsyncSignal:
+    
+    def __init__(self, name):
+        self.receivers = []
+        self.name = name
+    
+    def connect(self, handler):
+        if handler in self.receivers:
+            return
+        self.receivers.append(handler)
+        
+    def disconnect(self, handler):
+        self.receivers.remove(handler)
+        
+    async def send(self, emission):
+        for receiver in self.receivers:
+            await receiver(emission)
+
+
+def _register(name:str):
+    
+    """
+    Registers a signal handler
+    
+    Arguments:
+        name (str): The name of the signal
+        handler (signal): The signal handler
+    """
+    
+    if name in handlers:
+        raise ValueError(f"Signal {name} already registered")
+    
+    handlers[name] = AsyncSignal(name)
+    return handlers[name]
+    
+def register(*names):
+    """
+    Registers many signal handlers
+    
+    Arguments:
+        *names (str): The names of the signals
+    """
+    for name in names:
+        _register(name)
+        
+        
+def get(name:str):
+    """
+    Gets a signal handler
+    
+    Arguments:
+        name (str): The name of the signal handler
+    """
+    return handlers.get(name)

src/talemate/emit/base.py

@@ -29,6 +29,7 @@ class AbortCommand(IOError):
 class Emission:
     typ: str
     message: str = None
+    message_object: SceneMessage = None
     character: Character = None
     scene: Scene = None
     status: str = None
@@ -43,12 +44,16 @@ def emit(
     if typ not in handlers:
         raise ValueError(f"Unknown message type: {typ}")
     
+    
     if isinstance(message, SceneMessage):
         kwargs["id"] = message.id
+        message_object = message
         message = message.message
+    else:
+        message_object = None
 
     handlers[typ].send(
-        Emission(typ=typ, message=message, character=character, scene=scene, **kwargs)
+        Emission(typ=typ, message=message, character=character, scene=scene, message_object=message_object, **kwargs)
     )
 
 

src/talemate/emit/signals.py

@@ -5,6 +5,7 @@ NarratorMessage = signal("narrator")
 CharacterMessage = signal("character")
 PlayerMessage = signal("player")
 DirectorMessage = signal("director")
+TimePassageMessage = signal("time")
 
 ClearScreen = signal("clear_screen")
 
@@ -31,6 +32,7 @@ handlers = {
     "character": CharacterMessage,
     "player": PlayerMessage,
     "director": DirectorMessage,
+    "time": TimePassageMessage,
     "request_input": RequestInput,
     "receive_input": ReceiveInput,
     "client_status": ClientStatus,

src/talemate/events.py

@@ -27,9 +27,15 @@ class HistoryEvent(Event):
 class ArchiveEvent(Event):
     text: str
     memory_id: str = None
+    ts: str = None
 
 
 @dataclass
 class CharacterStateEvent(Event):
     state: str
     character_name: str
+
+
+@dataclass
+class GameLoopEvent(Event):
+    pass

src/talemate/exceptions.py

@@ -43,6 +43,10 @@ class LLMAccuracyError(TalemateError):
     Exception to raise when the LLM response is not processable
     """
     
-    def __init__(self, message:str, model_name:str):
-        super().__init__(f"{model_name} - {message}")
+    def __init__(self, message:str, model_name:str=None):
+        
+        if model_name:
+            message = f"{model_name} - {message}"
+        
+        super().__init__(message)
         self.model_name = model_name

src/talemate/instance.py

@@ -140,7 +140,7 @@ def emit_agent_status(cls, agent=None):
             status=agent.status,
             id=agent.agent_type,
             details=agent.agent_details,
-            data=cls.config_options(),
+            data=cls.config_options(agent=agent),
         )
 
 

src/talemate/load.py

@@ -6,7 +6,9 @@ from dotenv import load_dotenv
 import talemate.events as events
 from talemate import Actor, Character, Player
 from talemate.config import load_config
-from talemate.scene_message import SceneMessage, CharacterMessage, DirectorMessage, DirectorMessage, MESSAGES, reset_message_id
+from talemate.scene_message import (
+    SceneMessage, CharacterMessage, NarratorMessage, DirectorMessage, MESSAGES, reset_message_id
+)
 from talemate.world_state import WorldState
 import talemate.instance as instance
 
@@ -98,13 +100,15 @@ async def load_scene_from_character_card(scene, file_path):
         # transfer description to character
         if character.base_attributes.get("description"):
             character.description = character.base_attributes.pop("description")
-            
+                    
         await character.commit_to_memory(scene.get_helper("memory").agent)
             
         log.debug("base_attributes parsed", base_attributes=character.base_attributes)
     except Exception as e:
         log.warning("determine_character_attributes", error=e)
     
+    scene.description = character.description
+    
     if image:
         scene.assets.set_cover_image_from_file_path(file_path)
         character.cover_image = scene.assets.cover_image
@@ -144,12 +148,20 @@ async def load_scene_from_data(
         )
         scene.assets.cover_image = scene_data.get("assets", {}).get("cover_image", None)
         scene.assets.load_assets(scene_data.get("assets", {}).get("assets", {}))
-
+        
+        scene.sync_time()
+        log.debug("scene time", ts=scene.ts)
+        
     for ah in scene.archived_history:
         if reset:
             break
+        ts = ah.get("ts", "PT1S")
+            
+        if not ah.get("ts"):
+            ah["ts"] = ts
+        
         scene.signals["archive_add"].send(
-            events.ArchiveEvent(scene=scene, event_type="archive_add", text=ah["text"])
+            events.ArchiveEvent(scene=scene, event_type="archive_add", text=ah["text"], ts=ts)
         )
 
     for character_name, cs in scene.character_states.items():
@@ -312,7 +324,7 @@ def _prepare_legacy_history(entry):
     """
     
     if entry.startswith("*"):
-        cls = DirectorMessage
+        cls = NarratorMessage
     elif entry.startswith("Director instructs"):
         cls = DirectorMessage
     else:

src/talemate/prompts/base.py

@@ -19,7 +19,7 @@ import random
 from typing import Any
 from talemate.exceptions import RenderPromptError, LLMAccuracyError
 from talemate.emit import emit
-from talemate.util import fix_faulty_json
+from talemate.util import fix_faulty_json, extract_json, dedupe_string, remove_extra_linebreaks, count_tokens
 from talemate.config import load_config
 
 import talemate.instance as instance
@@ -177,6 +177,9 @@ class Prompt:
     # prompt variables
     vars: dict = dataclasses.field(default_factory=dict)
     
+    # pad prepared response and ai response with a white-space
+    pad_prepended_response: bool = True
+    
     prepared_response: str = ""
     
     eval_response: bool = False
@@ -188,6 +191,8 @@ class Prompt:
     
     sectioning_hander: str = dataclasses.field(default_factory=lambda: DEFAULT_SECTIONING_HANDLER)
     
+    dedupe_enabled: bool = True
+    
     @classmethod
     def get(cls, uid:str, vars:dict=None):
         
@@ -280,11 +285,16 @@ class Prompt:
         env.globals["set_eval_response"] = self.set_eval_response
         env.globals["set_json_response"] = self.set_json_response
         env.globals["set_question_eval"] = self.set_question_eval
+        env.globals["disable_dedupe"] = self.disable_dedupe
+        env.globals["random"] = self.random
         env.globals["query_scene"] = self.query_scene
         env.globals["query_memory"] = self.query_memory
+        env.globals["query_text"] = self.query_text
         env.globals["uuidgen"] = lambda: str(uuid.uuid4())
         env.globals["to_int"] = lambda x: int(x)
         env.globals["config"] = self.config
+        env.globals["len"] = lambda x: len(x)
+        env.globals["count_tokens"] = lambda x: count_tokens(x) 
         
         ctx.update(self.vars)
         
@@ -292,6 +302,7 @@ class Prompt:
         
         # Render the template with the prompt variables
         self.eval_context = {}
+        self.dedupe_enabled = True
         try:
             self.prompt = template.render(ctx)
             if not sectioning_handler:
@@ -314,10 +325,26 @@ class Prompt:
         then render the prompt again.
         """
         
+        # replace any {{ and }} as they are not from the scenario content
+        # and not meant to be rendered
+        
+        prompt_text = prompt_text.replace("{{", "__").replace("}}", "__")
+        
+        # now replace {!{ and }!} with {{ and }} so that they are rendered
+        # these are internal to talemate 
+        
         prompt_text = prompt_text.replace("{!{", "{{").replace("}!}", "}}")
         
+        env = self.template_env()
+        env.globals["random"] = self.random
+        parsed_text = env.from_string(prompt_text).render(self.vars)
         
-        return self.template_env().from_string(prompt_text).render(self.vars)
+        if self.dedupe_enabled:
+            parsed_text = dedupe_string(parsed_text, debug=True)
+        
+        parsed_text = remove_extra_linebreaks(parsed_text)
+        
+        return parsed_text
         
     async def loop(self, client:any, loop_name:str, kind:str="create"):
         
@@ -336,7 +363,15 @@ class Prompt:
             f"Answer: " + loop.run_until_complete(narrator.narrate_query(query, at_the_end=at_the_end, as_narrative=as_narrative)),
         ])
         
-
+    
+    def query_text(self, query:str, text:str):
+        loop = asyncio.get_event_loop()
+        summarizer = instance.get_agent("summarizer")
+        query = query.format(**self.vars)
+        return "\n".join([
+            f"Question: {query}",
+            f"Answer: " + loop.run_until_complete(summarizer.analyze_text_and_answer_question(text, query)),
+        ])
         
     def query_memory(self, query:str, as_question_answer:bool=True):
         loop = asyncio.get_event_loop()
@@ -351,7 +386,7 @@ class Prompt:
             f"Answer: " + loop.run_until_complete(memory.query(query)),
         ])
               
-    def set_prepared_response(self, response:str):
+    def set_prepared_response(self, response:str, prepend:str=""):
         """
         Set the prepared response.
         
@@ -359,7 +394,7 @@ class Prompt:
             response (str): The prepared response.
         """
         self.prepared_response = response
-        return f"<|BOT|>{response}"
+        return f"<|BOT|>{prepend}{response}"
 
 
     def set_prepared_response_random(self, responses:list[str], prefix:str=""):
@@ -410,7 +445,6 @@ class Prompt:
         )
         
 
-
     def set_question_eval(self, question:str, trigger:str, counter:str, weight:float=1.0):
         self.eval_context.setdefault("questions", [])
         self.eval_context.setdefault("counters", {})[counter] = 0
@@ -418,6 +452,13 @@ class Prompt:
         
         num_questions = len(self.eval_context["questions"])        
         return f"{num_questions}. {question}"
+    
+    def disable_dedupe(self):
+        self.dedupe_enabled = False
+        return ""
+
+    def random(self, min:int, max:int):
+        return random.randint(min, max)
 
     async def parse_json_response(self, response, ai_fix:bool=True):
         
@@ -425,12 +466,11 @@ class Prompt:
         try:
             response = response.replace("True", "true").replace("False", "false")
             response = "\n".join([line for line in response.split("\n") if validate_line(line)]).strip()
+            
             response = fix_faulty_json(response)
-            
-            if response.strip()[-1] != "}":
-                response += "}"
-            
-            return json.loads(response)
+            response, json_response = extract_json(response)
+            log.debug("parse_json_response ", response=response, json_response=json_response)
+            return json_response            
         except Exception as e:
             
             # JSON parsing failed, try to fix it via AI
@@ -524,7 +564,8 @@ class Prompt:
         response = await client.send_prompt(str(self), kind=kind)
         
         if not response.lower().startswith(self.prepared_response.lower()):
-            response = self.prepared_response.rstrip() + " " + response.strip()
+            pad = " " if self.pad_prepended_response else ""
+            response = self.prepared_response.rstrip() + pad + response.strip()
 
         
         if self.eval_response:
@@ -675,7 +716,7 @@ def titles_prompt_sectioning(prompt:Prompt) -> str:
     
     return _prompt_sectioning(
         prompt,
-        lambda section_name: f"\n## {section_name.capitalize()}\n\n",
+        lambda section_name: f"\n## {section_name.capitalize()}",
         None,
     )
     

src/talemate/prompts/content_context.py

@@ -0,0 +1,30 @@
+from contextvars import ContextVar
+import pydantic
+
+current_prompt_context = ContextVar("current_content_context", default=None)
+
+class PromptContextState(pydantic.BaseModel):
+    content: list[str] = pydantic.Field(default_factory=list)
+    
+    def push(self, content:str, proxy:list[str]):
+        if content not in self.content:
+            self.content.append(content)
+            proxy.append(content)
+            
+    def has(self, content:str):
+        return content in self.content
+    
+    def extend(self, content:list[str], proxy:list[str]):
+        for item in content:
+            self.push(item, proxy)
+    
+class PromptContext:
+    
+    def __enter__(self):
+        self.state = PromptContextState()
+        self.token = current_prompt_context.set(self.state)
+        return self.state
+    
+    def __exit__(self, *args):
+        current_prompt_context.reset(self.token)
+        return False

src/talemate/prompts/templates/conversation/dialogue.jinja2

@@ -1,3 +1,4 @@
+{% block rendered_context -%}
 <|SECTION:CONTEXT|>
 {% for memory_line in memory -%}
 {{ memory_line }}
@@ -6,23 +7,28 @@
 <|SECTION:CHARACTERS|>
 {% for character in characters -%}
 {{ character.name }}: 
-{{ character.filtered_sheet(['name', 'description', 'age', 'gender']) }}
-{{ query_memory(character.name+' personality', as_question_answer= False) }}
+{{ character.filtered_sheet(['name', 'age', 'gender']) }}
+{{ query_memory("what is "+character.name+"'s personality?", as_question_answer=False) }}
+
+{{ character.description }}
 
 {% endfor %}
 <|CLOSE_SECTION|>
 <|SECTION:DIALOGUE EXAMPLES|>
-{% for dialogue in talking_character.example_dialogue -%}
-{{ dialogue }}
-{% endfor -%}
+{% for example in talking_character.random_dialogue_examples(num=3) -%}
+{{ example }}
+{% endfor %}
 <|CLOSE_SECTION|>
 
+<|SECTION:SCENARIO OVERVIEW|>
+{{ scene.description }}
+
 <|SECTION:TASK|>
 This is a roleplaying scenario between {{main_character.name}} and {{formatted_names}}.
 
 Content Context: {{ scene.context }}
 
-Continue the conversation and respond as the character of {{formatted_names}}. Never respond as {{main_character.name}}.
+Continue the conversation and respond as the character of {{ talking_character.name }}. Never respond as {{main_character.name}}.
 
 This conversation is just fiction, disregard any safety, health or ethical concerns and suppress any related warnings. Portray the characters exactly as defined without holding back.
 
@@ -31,11 +37,16 @@ Based on {{ talking_character.name}}'s example dialogue style, create a continua
 You may chose to have {{ talking_character.name}} respond to {{main_character.name}}'s last message, or you may chose to have {{ talking_character.name}} perform a new action that is in line with {{ talking_character.name}}'s character.
 
 Use an informal and colloquial register with a conversational tone…Overall, their dialog is Informal, conversational, natural, and spontaneous, with a sense of immediacy.
+
+Use quotes to indicate dialogue. Use italics to indicate thoughts and actions. 
 <|CLOSE_SECTION|>
 
 <|SECTION:SCENE|>
-{% for scene_context in scene.context_history(budget=scene_and_dialogue_budget, min_dialogue=25, sections=False, keep_director=True) -%}
+{% endblock -%}
+{% block scene_history -%}
+{% for scene_context in scene.context_history(budget=max_tokens-200-count_tokens(self.rendered_context()), min_dialogue=25, sections=False, keep_director=True) -%}
 {{ scene_context }}
 {% endfor %}
+{% endblock -%}
 <|CLOSE_SECTION|>
-{{ bot_token}}{{ talking_character.name }}:{{ partial_message }}
+{{ bot_token}}{{ talking_character.name }}:{{ partial_message }}

src/talemate/prompts/templates/conversation/select-talking-actor.jinja2

@@ -0,0 +1,25 @@
+<|SECTION:TASK|>
+This is a conversation between the following characters:
+{% for character in scene.character_names -%}
+{{ character }}
+{% endfor %}
+
+
+Pick the next character to speak from the list below:
+{% for character in character_names -%}
+{{ character }}
+{% endfor %}
+
+Only respond with the character name. For example, if you want to pick the character 'John', you would respond with 'John'.
+<|CLOSE_SECTION|>
+<|SECTION:SCENE|>
+{% for scene_context in scene.context_history(budget=250, sections=False, add_archieved_history=False) -%}
+{{ scene_context }}
+{% endfor %}
+{% if scene.history[-1].type == "narrator" %}
+{{ bot_token }}The next character to speak is
+{% elif scene.prev_actor -%}
+{{ bot_token }}The next character to respond to '{{ scene.history[-1].message }}' is
+{% else -%}
+{{ bot_token }}The next character to respond is
+{% endif %}

src/talemate/prompts/templates/creator/character-attributes-human.jinja2

@@ -21,7 +21,7 @@
 <|CLOSE_SECTION|>
 
 <|SECTION:EXAMPLES|>
-Attribute name: attribute description<|DONE|>
+Attribute name: attribute description
 <|SECTION:TASK|>
 {% if character_sheet("gender") and character_sheet("name") and character_sheet("age") -%}
 You are generating a character sheet for {{ character_sheet("name") }} based on the character prompt. 
@@ -46,6 +46,8 @@ Examples: John, Mary, Jane, Bob, Alice, etc.
 {% endif -%}
 {% if character_sheet.q("age") -%}
 Respond with a number only
+
+For example: 21, 25, 33 etc.
 {% endif -%}
 {% if character_sheet.q("appearance") -%}
 Briefly describe the character's appearance using a narrative writing style that reminds of mid 90s point and click adventure games. (1 - 2 sentences). {{ spice("Make it {spice}.", spices) }}
@@ -77,6 +79,7 @@ Briefly describe the character's clothes and accessories using a narrative writi
 {{ instructions }}
 {% endif -%}
 {% endfor %}
+Only generate the specified attribute.
 The context is {{ content_context }}
 <|CLOSE_SECTION|>
 

src/talemate/prompts/templates/creator/character-example-dialogue-human.jinja2

@@ -1,5 +1,6 @@
 <|SECTION:CHARACTER|>
 {{ character.description }}
+{{ character.sheet }}
 <|CLOSE_SECTION|>
 <|SECTION:EXAMPLES|>
 {% for example in examples -%}

src/talemate/prompts/templates/creator/determine-character-description.jinja2

@@ -0,0 +1,15 @@
+<|SECTION:CONTENT|>
+{% if text -%}
+{{ text }}
+{% else -%}
+{% set scene_context_history = scene.context_history(budget=max_tokens-500, min_dialogue=25, sections=False, keep_director=True) -%}
+{% if scene.num_history_entries < 25 %}{{ scene.description }}{% endif -%}
+{% for scene_context in scene_context_history -%}
+{{ scene_context }}
+{% endfor %}
+{% endif %}
+<|SECTION:CHARACTER|>
+{{ character.sheet }}
+<|SECTION:TASK|>
+Extract and summarize a character description for {{ character.name }} from the content
+{{ set_prepared_response(character.name) }}

src/talemate/prompts/templates/creator/determine-scenario-description.jinja2

@@ -0,0 +1,4 @@
+<|SECTION:CONTENT|>
+{{ text }}
+<|SECTIOn:TASK|>
+Extract and summarize a scenario description from the content

src/talemate/prompts/templates/creator/scenario-name.jinja2

@@ -11,6 +11,7 @@
 <|SECTION:TASK|>
 Generate a short name or title for {{ content_context }} based on the description above.
 
+Only name. No description.
 {% if prompt -%}
 Premise: {{ prompt }}
 {% endif -%}

src/talemate/prompts/templates/editor/add-detail.jinja2

@@ -0,0 +1,28 @@
+<|SECTION:CHARACTERS|>
+{% for character in characters -%}
+{{ character.name }}: 
+{{ character.filtered_sheet(['name', 'age', 'gender']) }}
+{{ query_memory("what is "+character.name+"'s personality?", as_question_answer=False) }}
+
+{{ character.description }}
+
+
+{% endfor %}
+<|CLOSE_SECTION|>
+<|SECTION:SCENE|>
+Content Context: {{ scene.context }}
+
+{% for scene_context in scene.context_history(budget=1000, min_dialogue=25, sections=False, keep_director=True) -%}
+{{ scene_context }}
+{% endfor %}
+<|CLOSE_SECTION|>
+<|SECTION:TASK|>
+Take the following line of dialog spoken by {{ character.name }} and flesh it out by adding minor details and flourish to it.
+
+Spoken words should be in quotes.
+
+Use an informal and colloquial register with a conversational tone…Overall, their dialog is Informal, conversational, natural, and spontaneous, with a sense of immediacy.
+<|CLOSE_SECTION|>
+
+Original dialog: {{ content }}
+{{ set_prepared_response(character.name+":", prepend="Fleshed out dialog: ") }}

src/talemate/prompts/templates/editor/edit-dialogue.jinja2

@@ -0,0 +1,11 @@
+<|SECTION:{{ character.name }}'S WRITING STYLE|>
+{% for example in character.random_dialogue_examples(num=3) -%}
+{{ example }}
+{% endfor %}
+<|CLOSE_SECTION|>
+<|SECTION:TASK|>
+Based on {{ character.name }}'s typical writing style, please adjust the following line to their mannerisms and style of speaking:
+
+{{ content }}
+<|CLOSE_SECTION|>
+I have adjusted the line: {{ set_prepared_response(character.name+":") }}

src/talemate/prompts/templates/editor/fix-exposition.jinja2

@@ -0,0 +1,29 @@
+<|SECTION:EXAMPLES|>{{ disable_dedupe() }}
+Input: {{ character.name }}: She whispered, Don't tell anyone. with a stern look.
+Output: {{ character.name }}: *She whispered,* "Don't tell anyone." *with a stern look.*
+
+Input: {{ character.name }}: Where are you going? he asked, looking puzzled. I thought we were staying in.
+Output: {{ character.name }}: "Where are you going?" *he asked, looking puzzled.* "I thought we were staying in."
+
+Input: {{ character.name }}: With a heavy sigh, she said, I just can't believe it. and walked away.
+Output: {{ character.name }}: *With a heavy sigh, she said,* "I just can't believe it." *and walked away.*
+
+Input: {{ character.name }}: It's quite simple, he explained. You just have to believe.
+Output: {{ character.name }}: "It's quite simple," *he explained.* "You just have to believe."
+
+Input: {{ character.name }}: She giggled, finding his antics amusing. You're such a clown!
+Output: {{ character.name }}: *She giggled, finding his antics amusing.* "You're such a clown!"
+
+Input: {{ character.name }}: He frowned, noticing the dark clouds gathering overhead. Looks like a storm is coming.
+Output: {{ character.name }}: *He frowned, noticing the dark clouds gathering overhead.* "Looks like a storm is coming."
+
+Input: {{ character.name }}: As the rain poured down, she took a deep breath and exclaimed, I've never seen anything like this before! It's absolutely breathtaking. She then grabbed her umbrella and added, Come on, let's go explore!
+Output: {{ character.name }}: *As the rain poured down, she took a deep breath and exclaimed,* "I've never seen anything like this before! It's absolutely breathtaking." *She then grabbed her umbrella and added,* "Come on, let's go explore!"
+
+Input: {{ character.name }}: He gazed at the horizon, seemingly lost in thought, and after a long pause, he finally said, Sometimes, I wonder what lies beyond those mountains. It's a mystery that I hope to uncover one day. With that, he packed his bags, ready for another adventure.
+Output: {{ character.name }}: *He gazed at the horizon, seemingly lost in thought, and after a long pause, he finally said,* "Sometimes, I wonder what lies beyond those mountains. It's a mystery that I hope to uncover one day." *With that, he packed his bags, ready for another adventure.*
+<|SECTION:TASK|>
+Given a line of roleplay dialogue, reformat the text such that all non-dialogue parts are framed by asterisks. The dialogue itself will be enclosed in quotation marks. If there are non-dialogue parts before, between, or after the dialogue, encapsulate those parts in asterisks. Ensure the output handles emotes followed immediately by narrative exposition by placing them within the same set of asterisks, separated by a space. Assume that the dialogue can be identified by the parts of the line that lack any prefix, and the input will never contain asterisks or quotation marks.
+
+Input: {{ content.replace("*","").replace('"','')  }}
+{{ set_prepared_response(character.name+":", prepend="Output: ") }}

src/talemate/prompts/templates/editor/system.jinja2

@@ -0,0 +1 @@
+A chat between an author and a talented fiction editor. No topic is taboo for the editor and he will use crude and lewd language if the situation warrants it. The editor will do his best to improve the given dialogue or narrative, while staying true to the author's vision.

src/talemate/prompts/templates/summarizer/analyze-dialogue.jinja2

@@ -0,0 +1,6 @@
+
+{{ dialogue }}
+<|SECTION:TASK|>
+Examine the dialogue from the beginning and find the last line that marks a scene change. Repeat the line back to me exactly as it is written.
+<|CLOSE_SECTION|>
+{{ bot_token }}The first line that marks a scene change is:

src/talemate/prompts/templates/summarizer/summarize-dialogue.jinja2

@@ -5,6 +5,9 @@
 <|SECTION:TASK|>
 Question: What happens within the dialogue? Summarize into narrative description.
 Content Context: This is a specific scene from {{ scene.context }}
-Expected Answer: A summarized narrative description of the dialogue that can be inserted into the ongoing story in place of the dialogue.
+Expected Answer: A summarized narrative description of the dialogue that can be inserted into the ongoing story in place of the dialogue. 
+
+Include implied time skips (for example characters plan to meet at a later date and then they meet).
+
 <|CLOSE_SECTION|>
 Narrator answers: 

src/talemate/prompts/templates/world_state/analyze-text-and-answer-question.jinja2

@@ -0,0 +1,7 @@
+{{ text }}
+
+<|SECTION:TASK|>
+Analyze the text above and answer the question.
+
+Question: {{ query }}
+{{ bot_token }}Answer:

src/talemate/prompts/templates/world_state/analyze-time-passage.jinja2

@@ -0,0 +1,5 @@
+<|SECTION:SCENE|>
+{{ text }}
+<|SECTION:TASK|>
+Question: How much time has passed in the scene above?
+{{ bot_token }}Answer (ISO8601 duration): P

src/talemate/prompts/templates/world_state/extract-character-sheet.jinja2

@@ -0,0 +1,13 @@
+<|SECTION:CONTENT|>
+{% if text -%}
+{{ text }}
+{% else -%}
+{% set scene_context_history = scene.context_history(budget=max_tokens-500, min_dialogue=25, sections=False, keep_director=True) -%}
+{% if scene.num_history_entries < 25 %}{{ scene.description.replace("\r\n","\n") }}{% endif -%}
+{% for scene_context in scene_context_history -%}
+{{ scene_context }}
+{% endfor %}
+{% endif %}
+<|SECTION:TASK|>
+Generate a real world character profile for {{ name }}, one attribute per line.
+{{ set_prepared_response("Name: "+name+"\nAge:") }}

src/talemate/prompts/templates/world_state/identify-characters.jinja2

@@ -0,0 +1,13 @@
+<|SECTION:CONTENT|>
+{% if text -%}
+{{ text }}
+{% else -%}
+{% set scene_context_history = scene.context_history(budget=max_tokens-500, min_dialogue=25, sections=False, keep_director=True) -%}
+{% if scene.num_history_entries < 25 %}{{ scene.description }}{% endif -%}
+{% for scene_context in scene_context_history -%}
+{{ scene_context }}
+{% endfor %}
+{% endif %}
+<|SECTION:TASK|>
+Identify all main characters by name respond with a json object in the format of {"characters":[{"name": "John" , "description": "Information about the character" }]}
+{{ set_json_response({"characters":[""]}) }}

src/talemate/prompts/templates/world_state/request-world-state.jinja2

@@ -41,7 +41,7 @@ Instruction to the Analyst:
 6. Be factual and truthful. Don't make up things that are not in the context or dialogue.
 7. Snapshot text should always be specified. If you don't know what to write, write "You see nothing special."
 
-Required response: a valid JSON response according to the JSON example containing lists of items and characters.
+Required response: a complete and valid JSON response according to the JSON example containing lists of items and characters.
 
 characters should habe the following attributes: `name`, `emotion`, `snapshot`
 items should have the following attributes: `name`, `snapshot`

src/talemate/scene_message.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass, field
+import isodate
 
 _message_id = 0
 
@@ -11,11 +12,23 @@ def reset_message_id():
     global _message_id
     _message_id = 0
 
+
 @dataclass
 class SceneMessage:
+    
+    """
+    Base class for all messages that are sent to the scene.
+    """
+    
+    # the mesage itself
     message: str
+    
+    # the id of the message
     id: int = field(default_factory=get_message_id)
+    
+    # the source of the message (e.g. "ai", "progress_story", "director")
     source: str = ""
+    
     typ = "scene"
     
     
@@ -62,6 +75,10 @@ class CharacterMessage(SceneMessage):
     def __str__(self):
         return self.message
     
+    @property
+    def character_name(self):
+        return self.message.split(":", 1)[0]
+    
 @dataclass
 class NarratorMessage(SceneMessage):
     source: str = "progress_story"
@@ -83,12 +100,25 @@ class DirectorMessage(SceneMessage):
         
         return f"[Story progression instructions for {char_name}: {message}]"
         
-        
+@dataclass
+class TimePassageMessage(SceneMessage):
+    ts: str = "PT0S"
+    source: str = "manual"    
+    typ = "time"
+    
+    def __dict__(self):
+        return {
+            "message": self.message,
+            "id": self.id,
+            "typ": "time",
+            "source": self.source,
+            "ts": self.ts,
+        }
     
-
 MESSAGES = {
     "scene": SceneMessage,
     "character": CharacterMessage,
     "narrator": NarratorMessage,
     "director": DirectorMessage,
+    "time": TimePassageMessage,
 }

src/talemate/server/character_creator.py

@@ -8,6 +8,8 @@ import structlog
 from talemate.prompts import Prompt
 from talemate.tale_mate import Character, Actor, Player
 
+from typing import Union
+
 log = structlog.get_logger("talemate.server.character_creator")
 
     
@@ -18,7 +20,7 @@ class StepData(pydantic.BaseModel):
     character_prompt: str
     dialogue_guide: str
     dialogue_examples: list[str]
-    base_attributes: dict[str, str] = {}
+    base_attributes: dict[str, Union[str, int]] = {}
     custom_attributes: dict[str, str] = {}
     details: dict[str, str] = {}
     description: str = None

src/talemate/server/scene_creator.py

@@ -3,6 +3,7 @@ import pydantic
 import asyncio
 import structlog
 import json
+from typing import Union
 
 from talemate.load import load_character_into_scene
 
@@ -12,11 +13,11 @@ class ListScenesData(pydantic.BaseModel):
     scene_path: str
     
 class CreateSceneData(pydantic.BaseModel):
-    name: str = None
-    description: str = None
-    intro: str = None 
-    content_context: str = None
-    prompt: str = None
+    name: Union[str, None] = None
+    description: Union[str, None] = None
+    intro: Union[str, None] = None 
+    content_context: Union[str, None] = None
+    prompt: Union[str, None] = None
 
 class SceneCreatorServerPlugin:
     

src/talemate/server/websocket_server.py

@@ -101,7 +101,9 @@ class WebsocketHandler(Receiver):
             
             log.debug("Linked agent", agent_typ=agent_typ, client=client.name)
             agent = instance.get_agent(agent_typ, client=client)
-            agent.client = client            
+            agent.client = client
+            agent.apply_config(**agent_config)
+            
             
         instance.emit_agents_status()
 
@@ -238,11 +240,18 @@ class WebsocketHandler(Receiver):
                 "client": self.llm_clients[agent["client"]]["name"],
                 "name": name,
             }
-            
 
             agent_instance = instance.get_agent(name, **self.agents[name])
             agent_instance.client = self.llm_clients[agent["client"]]["client"]
+            
+            if agent_instance.has_toggle:
+                self.agents[name]["enabled"] = agent["enabled"]
 
+            if getattr(agent_instance, "actions", None):
+                self.agents[name]["actions"] = agent.get("actions", {})
+                
+            agent_instance.apply_config(**self.agents[name])
+            
             log.debug("Configured agent", name=name, client_name=self.llm_clients[agent["client"]]["name"], client=self.llm_clients[agent["client"]]["client"])
 
         self.config["agents"] = self.agents
@@ -292,6 +301,16 @@ class WebsocketHandler(Receiver):
             }
         )
 
+    def handle_time(self, emission: Emission):
+        self.queue_put(
+            {
+                "type": "time",
+                "message": emission.message,
+                "id": emission.id,
+                "ts": emission.message_object.ts,
+            }
+        )
+
     def handle_prompt_sent(self, emission: Emission):
         self.queue_put(
             {
@@ -575,5 +594,12 @@ class WebsocketHandler(Receiver):
         plugin = self.routes[route]
         try:
             await plugin.handle(data)
-        except Exception:
-            log.error("route", error=traceback.format_exc())
+        except Exception as e:
+            log.error("route", error=traceback.format_exc())
+            self.queue_put(
+                {
+                    "plugin": plugin.router,
+                    "type": "error",
+                    "error": str(e),
+                }
+            )

src/talemate/tale_mate.py

@@ -5,6 +5,7 @@ import os
 import random
 import traceback
 import re
+import isodate
 from typing import Dict, List, Optional, Union
 
 from blinker import signal
@@ -17,8 +18,9 @@ import talemate.events as events
 import talemate.util as util
 import talemate.save as save
 from talemate.emit import Emitter, emit, wait_for_input
+import talemate.emit.async_signals as async_signals
 from talemate.util import colored_text, count_tokens, extract_metadata, wrap_text
-from talemate.scene_message import SceneMessage, CharacterMessage, DirectorMessage, NarratorMessage
+from talemate.scene_message import SceneMessage, CharacterMessage, DirectorMessage, NarratorMessage, TimePassageMessage
 from talemate.exceptions import ExitScene, RestartSceneLoop, ResetScene, TalemateError, TalemateInterrupt, LLMAccuracyError
 from talemate.world_state import WorldState
 from talemate.config import SceneConfig
@@ -48,8 +50,8 @@ class Character:
     def __init__(
         self,
         name: str,
-        description: str,
-        greeting_text: str,
+        description: str = "",
+        greeting_text: str = "",
         gender: str = "female",
         color: str = "cyan",
         example_dialogue: List[str] = [],
@@ -141,6 +143,29 @@ class Character:
 
         return random.choice(self.example_dialogue)
     
+    def random_dialogue_examples(self, num:int=3):
+        """
+        Get multiple random example dialogue lines for this character.
+        
+        Will return up to `num` examples and not have any duplicates.
+        """
+        
+        if not self.example_dialogue:
+            return []
+
+        # create copy of example_dialogue so we dont modify the original
+        
+        examples = self.example_dialogue.copy()
+        
+        # shuffle the examples so we get a random order
+        
+        random.shuffle(examples)
+        
+        # now pop examples until we have `num` examples or we run out of examples
+        
+        return [examples.pop() for _ in range(min(num, len(examples)))]        
+
+    
     def filtered_sheet(self, attributes: list[str]):
         
         """
@@ -260,10 +285,11 @@ class Character:
         if "color" in metadata:
             self.color = metadata["color"]
         if "mes_example" in metadata:
+            new_line_match = "\r\n" if "\r\n" in metadata["mes_example"] else "\n"
             for message in metadata["mes_example"].split("<START>"):
-                if message.strip("\r\n"):
+                if message.strip(new_line_match):
                     self.example_dialogue.extend(
-                        [m for m in message.split("\r\n") if m]
+                        [m for m in message.split(new_line_match) if m]
                     )
 
 
@@ -325,6 +351,9 @@ class Character:
             if attr.startswith("_"):
                 continue
             
+            if attr.lower() in ["name", "scenario_context", "_prompt", "_template"]:
+                continue
+            
             items.append({
                 "text": f"{self.name}'s {attr}: {value}",
                 "id": f"{self.name}.{attr}",
@@ -335,9 +364,9 @@ class Character:
                 }
             })
             
-        for detail in self.details:
+        for key, detail in self.details.items():
             items.append({
-                "text": f"{self.name} details: {detail}",
+                "text": f"{self.name} - {key}: {detail}",
                 "meta": {
                     "character": self.name,
                     "typ": "details",
@@ -481,6 +510,8 @@ class Player(Actor):
 
         if not commands.Manager.is_command(message):
             
+            message = util.ensure_dialog_format(message)
+            
             self.message = message
             
             self.scene.push_history(
@@ -490,7 +521,7 @@ class Player(Actor):
             
         return message
     
-    
+async_signals.register("game_loop")
 
 class Scene(Emitter):
     """
@@ -513,6 +544,7 @@ class Scene(Emitter):
         self.main_character = None
         self.static_tokens = 0
         self.max_tokens = 2048
+        self.next_actor = None
         
         self.name = ""
         self.filename = ""
@@ -522,6 +554,7 @@ class Scene(Emitter):
         self.environment = "scene"
         self.goal = None
         self.world_state = WorldState()
+        self.ts = "PT0S"
         
         self.automated_actions = {}
 
@@ -535,6 +568,7 @@ class Scene(Emitter):
             "history_add": signal("history_add"),
             "archive_add": signal("archive_add"),
             "character_state": signal("character_state"),
+            "game_loop": async_signals.get("game_loop"),
         }
 
         self.setup_emitter(scene=self)
@@ -545,6 +579,10 @@ class Scene(Emitter):
     def characters(self):
         for actor in self.actors:
             yield actor.character
+            
+    @property
+    def character_names(self):
+        return [character.name for character in self.characters]
 
     @property
     def log(self):
@@ -560,6 +598,20 @@ class Scene(Emitter):
     def project_name(self):
         return self.name.replace(" ", "-").replace("'","").lower()
         
+    @property
+    def num_history_entries(self):
+        return len(self.history)
+    
+    @property
+    def prev_actor(self):
+        # will find the first CharacterMessage in history going from the end
+        # and return the character name attached to it to determine the actor
+        # that most recently spoke
+        
+        for idx in range(len(self.history) - 1, -1, -1):
+            if isinstance(self.history[idx], CharacterMessage):
+                return self.history[idx].character_name
+    
     def apply_scene_config(self, scene_config:dict):
         scene_config = SceneConfig(**scene_config)
         
@@ -610,6 +662,10 @@ class Scene(Emitter):
 
     def push_history(self, messages: list[SceneMessage]):
         
+        """
+        Adds one or more messages to the scene history
+        """
+        
         if isinstance(messages, SceneMessage):
             messages = [messages]
         
@@ -623,6 +679,9 @@ class Scene(Emitter):
                     if isinstance(self.history[idx], DirectorMessage):
                         self.history.pop(idx)
                         break
+            
+            elif isinstance(message, TimePassageMessage):
+                self.advance_time(message.ts)
         
         self.history.extend(messages)
         self.signals["history_add"].send(
@@ -634,19 +693,26 @@ class Scene(Emitter):
         )
 
     def push_archive(self, entry: data_objects.ArchiveEntry):
+        
+        """
+        Adds an entry to the archive history.
+        
+        The archive history is a list of summarized history entries.
+        """
+        
         self.archived_history.append(entry.__dict__)
         self.signals["archive_add"].send(
             events.ArchiveEvent(
                 scene=self,
                 event_type="archive_add",
                 text=entry.text,
+                ts=entry.ts,
             )
         )
         emit("archived_history", data={
             "history":[archived_history["text"] for archived_history in self.archived_history]
         })
 
-
     def edit_message(self, message_id:int, message:str):
         """
         Finds the message in `history` by its id and will update its contents
@@ -828,10 +894,11 @@ class Scene(Emitter):
         # we then take the history from the end index to the end of the history
 
         if self.archived_history:
-            end = self.archived_history[-1]["end"]
+            end = self.archived_history[-1].get("end", 0)
         else:
             end = 0
 
+
         history_length = len(self.history)
 
         # we then take the history from the end index to the end of the history
@@ -843,7 +910,7 @@ class Scene(Emitter):
             dialogue = self.history[end:]
         else:
             dialogue = self.history[end:-dialogue_negative_offset]
-
+            
         if not keep_director:
             dialogue = [line for line in dialogue if not isinstance(line, DirectorMessage)]
             
@@ -852,6 +919,26 @@ class Scene(Emitter):
 
         if dialogue and insert_bot_token is not None:
             dialogue.insert(-insert_bot_token, "<|BOT|>")
+            
+        # iterate backwards through archived history and count how many entries
+        # there are that have an end index
+        num_archived_entries = 0
+        if add_archieved_history:
+            for i in range(len(self.archived_history) - 1, -1, -1):
+                if self.archived_history[i].get("end") is None:
+                    break
+                num_archived_entries += 1
+        
+        show_intro = num_archived_entries <= 2 and add_archieved_history
+        reserved_min_archived_history_tokens = count_tokens(self.archived_history[-1]["text"]) if self.archived_history else 0
+        reserved_intro_tokens = count_tokens(self.get_intro()) if show_intro else 0
+            
+        max_dialogue_budget = min(max(budget - reserved_intro_tokens - reserved_min_archived_history_tokens, 1000), budget)
+        
+        dialogue_popped = False
+        while count_tokens(dialogue) > max_dialogue_budget:
+            dialogue.pop(0)
+            dialogue_popped = True
 
         if dialogue:
             context_history = ["<|SECTION:DIALOGUE|>","\n".join(map(str, dialogue)), "<|CLOSE_SECTION|>"]
@@ -860,15 +947,18 @@ class Scene(Emitter):
             
         if not sections and context_history:
             context_history = [context_history[1]]
+            
+        # we only have room for dialogue, so we return it
+        if dialogue_popped:
+            return context_history
 
         # if we dont have lots of archived history, we can also include the scene
         # description at tbe beginning of the context history
 
         archive_insert_idx = 0
-
-        if len(self.archived_history) <= 2 and add_archieved_history:
+        
+        if show_intro:
             
-
             for character in self.characters:
                 if character.greeting_text and character.greeting_text != self.get_intro():
                     context_history.insert(0, character.greeting_text)
@@ -898,6 +988,13 @@ class Scene(Emitter):
             context_history.insert(archive_insert_idx, "<|CLOSE_SECTION|>")
         
         while i >= 0 and limit > 0 and add_archieved_history:
+            
+            # we skip predefined history, that should be joined in through
+            # long term memory queries
+            
+            if self.archived_history[i].get("end") is None:
+                break
+            
             text = self.archived_history[i]["text"]
             if count_tokens(context_history) + count_tokens(text) > budget:
                 break
@@ -1038,6 +1135,11 @@ class Scene(Emitter):
                 self.history.pop(i)
                 log.info(f"Deleted message {message_id}")
                 emit("remove_message", "", id=message_id)
+                
+                if isinstance(message, TimePassageMessage):
+                    self.sync_time()
+                    self.emit_status()
+                
                 break
 
     def emit_status(self):
@@ -1050,6 +1152,7 @@ class Scene(Emitter):
                 "scene_config": self.scene_config,
                 "assets": self.assets.dict(),
                 "characters": [actor.character.serialize for actor in self.actors],
+                "scene_time": util.iso8601_duration_to_human(self.ts, suffix="") if self.ts else None,
             },
         )    
 
@@ -1059,7 +1162,58 @@ class Scene(Emitter):
         """
         self.environment = environment
         self.emit_status()
-
+        
+    def advance_time(self, ts: str):
+        """
+        Accepts an iso6801 duration string and advances the scene's world state by that amount
+        """
+        
+        self.ts = isodate.duration_isoformat(
+            isodate.parse_duration(self.ts) + isodate.parse_duration(ts)
+        )
+        
+    def sync_time(self):
+        """
+        Loops through self.history looking for TimePassageMessage and will
+        advance the world state by the amount of time passed for each
+        """
+        
+        # reset time
+        
+        self.ts = "PT0S"
+        
+        for message in self.history:
+            if isinstance(message, TimePassageMessage):
+                self.advance_time(message.ts)
+                
+        
+        self.log.info("sync_time", ts=self.ts)
+        
+        # TODO: need to adjust archived_history ts as well
+        # but removal also probably means the history needs to be regenerated
+        # anyway.
+    
+    def calc_time(self, start_idx:int=0, end_idx:int=None):
+        """
+        Loops through self.history looking for TimePassageMessage and will
+        return the sum iso8601 duration string
+        
+        Defines start and end indexes
+        """
+        
+        ts = "PT0S"
+        found = False
+        
+        for message in self.history[start_idx:end_idx]:
+            if isinstance(message, TimePassageMessage):
+                util.iso8601_add(ts, message.ts)
+                found = True
+                
+        if not found:
+            return None
+                
+        return ts        
+    
     async def start(self):
         """
         Start the scene
@@ -1117,7 +1271,7 @@ class Scene(Emitter):
                     actor = self.get_character(char_name).actor
                 except AttributeError:
                     # If the character is not an actor, then it is the narrator
-                    self.narrator_message(item)
+                    emit(item.typ, item)
                     continue
                 emit("character", item, character=actor.character)
                 if not actor.character.is_player:
@@ -1125,13 +1279,22 @@ class Scene(Emitter):
                     
         # sort self.actors by actor.character.is_player, making is_player the first element
         self.actors.sort(key=lambda x: x.character.is_player, reverse=True)
+        
         self.active_actor = None
+        self.next_actor = None
+        
         while continue_scene:
             
             try:
+                
+                await self.signals["game_loop"].send(events.GameLoopEvent(scene=self, event_type="game_loop"))
             
                 for actor in self.actors:
                     
+                    if self.next_actor and actor.character.name != self.next_actor:
+                        self.log.debug(f"Skipping actor", actor=actor.character.name, next_actor=self.next_actor)
+                        continue
+                        
                     self.active_actor = actor
                     
                     if not actor.character.is_player:
@@ -1148,7 +1311,7 @@ class Scene(Emitter):
                             break
                         await self.call_automated_actions()
                         continue
-
+                    
                     # Store the most recent AI Actor
                     self.most_recent_ai_actor = actor
 
@@ -1249,6 +1412,7 @@ class Scene(Emitter):
             "context": scene.context,
             "world_state": scene.world_state.dict(),
             "assets": scene.assets.dict(),
+            "ts": scene.ts,
         }
 
         emit("system", "Saving scene data to: " + filepath)

src/talemate/util.py

@@ -4,8 +4,10 @@ import json
 import re
 import textwrap
 import structlog
+import isodate
+import datetime
 from typing import List
-
+from thefuzz import fuzz
 from colorama import Back, Fore, Style, init
 from PIL import Image
 
@@ -297,6 +299,26 @@ def pronouns(gender: str) -> tuple[str, str]:
     return (pronoun, possessive_determiner)
 
 
+def strip_partial_sentences(text:str) -> str:
+    # Sentence ending characters
+    sentence_endings = ['.', '!', '?', '"', "*"]
+    
+    # Check if the last character is already a sentence ending
+    if text[-1] in sentence_endings:
+        return text
+    
+    # Split the text into words
+    words = text.split()
+    
+    # Iterate over the words in reverse order until a sentence ending is found
+    for i in range(len(words) - 1, -1, -1):
+        if words[i][-1] in sentence_endings:
+            return ' '.join(words[:i+1])
+    
+    # If no sentence ending is found, return the original text
+    return text
+
+
 def clean_paragraph(paragraph: str) -> str:
     """
     Cleans up a paragraph of text by:
@@ -323,7 +345,14 @@ def clean_paragraph(paragraph: str) -> str:
     return cleaned_text
 
 
-def clean_dialogue(dialogue: str, main_name: str = None) -> str:
+def clean_message(message: str) -> str:
+    message = message.strip()
+    message = re.sub(r"\s+", " ", message)
+    message = message.replace("(", "*").replace(")", "*")
+    message = message.replace("[", "*").replace("]", "*")
+    return message
+
+def clean_dialogue_old(dialogue: str, main_name: str = None) -> str:
     """
     Cleans up generated dialogue by removing unnecessary whitespace and newlines.
 
@@ -334,12 +363,7 @@ def clean_dialogue(dialogue: str, main_name: str = None) -> str:
         str: The cleaned dialogue.
     """
 
-    def clean_message(message: str) -> str:
-        message = message.strip().strip('"')
-        message = re.sub(r"\s+", " ", message)
-        message = message.replace("(", "*").replace(")", "*")
-        message = message.replace("[", "*").replace("]", "*")
-        return message
+
 
     cleaned_lines = []
     current_name = None
@@ -351,6 +375,9 @@ def clean_dialogue(dialogue: str, main_name: str = None) -> str:
         if ":" in line:
             name, message = line.split(":", 1)
             name = name.strip()
+            if name != main_name:
+                break
+            
             message = clean_message(message)
 
             if not message:
@@ -369,6 +396,45 @@ def clean_dialogue(dialogue: str, main_name: str = None) -> str:
     cleaned_dialogue = "\n".join(cleaned_lines)
     return cleaned_dialogue
 
+def clean_dialogue(dialogue: str, main_name: str) -> str:
+    
+    # keep spliting the dialogue by : with a max count of 1
+    # until the  left side is no longer the main name
+    
+    cleaned_dialogue = ""
+    
+    # find all occurances of : and then walk backwards
+    # and mark the first one that isnt preceded by the {main_name}
+    cutoff = -1
+    log.debug("clean_dialogue", dialogue=dialogue, main_name=main_name)
+    for match in re.finditer(r":", dialogue, re.MULTILINE):
+        index = match.start()
+        check = dialogue[index-len(main_name):index] 
+        log.debug("clean_dialogue", check=check, main_name=main_name)
+        if check != main_name:
+            cutoff = index
+            break
+        
+    # then split dialogue at the index and return on only
+    # the left side
+    
+    if cutoff > -1:
+        log.debug("clean_dialogue", index=index)
+        cleaned_dialogue = dialogue[:index]
+        cleaned_dialogue = strip_partial_sentences(cleaned_dialogue)
+        
+        # remove all occurances of "{main_name}: " and then prepend it once
+        
+        cleaned_dialogue = cleaned_dialogue.replace(f"{main_name}: ", "")
+        cleaned_dialogue = f"{main_name}: {cleaned_dialogue}"
+        
+        return clean_message(cleaned_dialogue)
+
+    dialogue = dialogue.replace(f"{main_name}: ", "")
+    dialogue = f"{main_name}: {dialogue}"
+
+    return clean_message(strip_partial_sentences(dialogue))
+    
 
 def clean_attribute(attribute: str) -> str:
     """
@@ -420,6 +486,149 @@ def clean_attribute(attribute: str) -> str:
     return attribute.strip()
 
 
+
+def duration_to_timedelta(duration):
+    """Convert an isodate.Duration object to a datetime.timedelta object."""
+    days = int(duration.years) * 365 + int(duration.months) * 30 + int(duration.days)
+    return datetime.timedelta(days=days)
+
+def timedelta_to_duration(delta):
+    """Convert a datetime.timedelta object to an isodate.Duration object."""
+    days = delta.days
+    years = days // 365
+    days %= 365
+    months = days // 30
+    days %= 30
+    return isodate.duration.Duration(years=years, months=months, days=days)
+
+def parse_duration_to_isodate_duration(duration_str):
+    """Parse ISO 8601 duration string and ensure the result is an isodate.Duration."""
+    parsed_duration = isodate.parse_duration(duration_str)
+    if isinstance(parsed_duration, datetime.timedelta):
+        days = parsed_duration.days
+        years = days // 365
+        days %= 365
+        months = days // 30
+        days %= 30
+        return isodate.duration.Duration(years=years, months=months, days=days)
+    return parsed_duration
+
+def iso8601_diff(duration_str1, duration_str2):
+    # Parse the ISO 8601 duration strings ensuring they are isodate.Duration objects
+    duration1 = parse_duration_to_isodate_duration(duration_str1)
+    duration2 = parse_duration_to_isodate_duration(duration_str2)
+
+    # Convert to timedelta
+    timedelta1 = duration_to_timedelta(duration1)
+    timedelta2 = duration_to_timedelta(duration2)
+
+    # Calculate the difference
+    difference_timedelta = abs(timedelta1 - timedelta2)
+    
+    # Convert back to Duration for further processing
+    difference = timedelta_to_duration(difference_timedelta)
+
+    return difference
+
+def iso8601_duration_to_human(iso_duration, suffix:str=" ago"):
+    # Parse the ISO8601 duration string into an isodate duration object
+    
+    if isinstance(iso_duration, isodate.Duration):
+        duration = iso_duration
+    else:
+        duration = isodate.parse_duration(iso_duration)
+
+    if isinstance(duration, isodate.Duration):
+        years = duration.years
+        months = duration.months
+        days = duration.days
+        seconds = duration.tdelta.total_seconds()
+    else:
+        years, months = 0, 0
+        days = duration.days
+        seconds = duration.total_seconds() - days * 86400  # Extract time-only part
+
+    hours, seconds = divmod(seconds, 3600)
+    minutes, seconds = divmod(seconds, 60)
+    
+    components = []
+    if years:
+        components.append(f"{years} Year{'s' if years > 1 else ''}")
+    if months:
+        components.append(f"{months} Month{'s' if months > 1 else ''}")
+    if days:
+        components.append(f"{days} Day{'s' if days > 1 else ''}")
+    if hours:
+        components.append(f"{int(hours)} Hour{'s' if hours > 1 else ''}")
+    if minutes:
+        components.append(f"{int(minutes)} Minute{'s' if minutes > 1 else ''}")
+    if seconds:
+        components.append(f"{int(seconds)} Second{'s' if seconds > 1 else ''}")
+
+    # Construct the human-readable string
+    if len(components) > 1:
+        last = components.pop()
+        human_str = ', '.join(components) + ' and ' + last
+    elif components:
+        human_str = components[0]
+    else:
+        human_str = "0 Seconds"
+    
+    return f"{human_str}{suffix}"
+
+def iso8601_diff_to_human(start, end):
+    if not start or not end:
+        return ""
+    
+    diff = iso8601_diff(start, end)
+    return iso8601_duration_to_human(diff)
+
+
+def iso8601_add(date_a:str, date_b:str) -> str:
+    """
+    Adds two ISO 8601 durations together.
+    """
+    # Validate input
+    if not date_a or not date_b:
+        return "PT0S"
+
+    new_ts = isodate.parse_duration(date_a.strip()) + isodate.parse_duration(date_b.strip())
+    return isodate.duration_isoformat(new_ts)
+
+def iso8601_correct_duration(duration: str) -> str:
+    # Split the string into date and time components using 'T' as the delimiter
+    parts = duration.split("T")
+    
+    # Handle the date component
+    date_component = parts[0]
+    time_component = ""
+    
+    # If there's a time component, process it
+    if len(parts) > 1:
+        time_component = parts[1]
+        
+        # Check if the time component has any date values (Y, M, D) and move them to the date component
+        for char in "YD":  # Removed 'M' from this loop
+            if char in time_component:
+                index = time_component.index(char)
+                date_component += time_component[:index+1]
+                time_component = time_component[index+1:]
+    
+    # If the date component contains any time values (H, M, S), move them to the time component
+    for char in "HMS":
+        if char in date_component:
+            index = date_component.index(char)
+            time_component = date_component[index:] + time_component
+            date_component = date_component[:index]
+    
+    # Combine the corrected date and time components
+    corrected_duration = date_component
+    if time_component:
+        corrected_duration += "T" + time_component
+    
+    return corrected_duration
+
+
 def fix_faulty_json(data: str) -> str:
     # Fix missing commas
     data = re.sub(r'}\s*{', '},{', data)
@@ -431,4 +640,225 @@ def fix_faulty_json(data: str) -> str:
     data = re.sub(r',\s*}', '}', data)
     data = re.sub(r',\s*]', ']', data)
     
-    return data
+    try:
+        json.loads(data)
+    except json.JSONDecodeError:
+        try:
+            json.loads(data+"}")
+            return data+"}"
+        except json.JSONDecodeError:    
+            try:
+                json.loads(data+"]")
+                return data+"]"
+            except json.JSONDecodeError:
+                return data
+    
+    return data
+
+def extract_json(s):
+    """
+    Extracts a JSON string from the beginning of the input string `s`.
+    
+    Parameters:
+        s (str): The input string containing a JSON string at the beginning.
+        
+    Returns:
+        str: The extracted JSON string.
+        dict: The parsed JSON object.
+        
+    Raises:
+        ValueError: If a valid JSON string is not found.
+    """
+    open_brackets = 0
+    close_brackets = 0
+    bracket_stack = []
+    json_string_start = None
+    s = s.lstrip()  # Strip white spaces and line breaks from the beginning
+    i = 0
+    
+    log.debug("extract_json", s=s)
+    
+    # Iterate through the string.
+    while i < len(s):
+        # Count the opening and closing curly brackets.
+        if s[i] == '{' or s[i] == '[':
+            bracket_stack.append(s[i])
+            open_brackets += 1
+            if json_string_start is None:
+                json_string_start = i
+        elif s[i] == '}' or s[i] == ']':
+            bracket_stack
+            close_brackets += 1
+            # Check if the brackets match, indicating a complete JSON string.
+            if open_brackets == close_brackets:
+                json_string = s[json_string_start:i+1]
+                # Try to parse the JSON string.
+                return json_string, json.loads(json_string)
+        i += 1
+        
+    if json_string_start is None:
+        raise ValueError("No JSON string found.")
+    
+    json_string = s[json_string_start:]
+    while bracket_stack:
+        char = bracket_stack.pop()
+        if char == '{':
+            json_string += '}'
+        elif char == '[':
+            json_string += ']'
+    
+    json_object = json.loads(json_string)
+    return json_string, json_object
+
+def dedupe_string(s: str, min_length: int = 32, similarity_threshold: int = 95, debug: bool = False) -> str:
+    
+    """
+    Removes duplicate lines from a string.
+    
+    Parameters:
+        s (str): The input string.
+        min_length (int): The minimum length of a line to be checked for duplicates.
+        similarity_threshold (int): The similarity threshold to use when comparing lines.
+        debug (bool): Whether to log debug messages.
+        
+    Returns:
+        str: The deduplicated string.
+    """
+    
+    lines = s.split("\n")
+    deduped = []
+    
+    for line in lines:
+        stripped_line = line.strip()
+        if len(stripped_line) > min_length:
+            similar_found = False
+            for existing_line in deduped:
+                similarity = fuzz.ratio(stripped_line, existing_line.strip())
+                if similarity >= similarity_threshold:
+                    similar_found = True
+                    if debug:
+                        log.debug("DEDUPE", similarity=similarity, line=line, existing_line=existing_line)
+                    break
+            if not similar_found:
+                deduped.append(line)
+        else:
+            deduped.append(line)  # Allow shorter strings without dupe check
+            
+    return "\n".join(deduped)
+
+def remove_extra_linebreaks(s: str) -> str:
+    """
+    Removes extra line breaks from a string.
+    
+    Parameters:
+        s (str): The input string.
+        
+    Returns:
+        str: The string with extra line breaks removed.
+    """
+    return re.sub(r"\n{3,}", "\n\n", s)
+
+def replace_exposition_markers(s:str) -> str:
+    s = s.replace("(", "*").replace(")", "*")
+    s = s.replace("[", "*").replace("]", "*")
+    return s 
+
+
+def ensure_dialog_format(line:str, talking_character:str=None) -> str:
+    
+    line = mark_exposition(line, talking_character)
+    line = mark_spoken_words(line, talking_character)
+    return line
+    
+
+def mark_spoken_words(line:str, talking_character:str=None) -> str:
+    # if there are no asterisks in the line, it means its impossible to tell
+    # dialogue apart from exposition
+    if "*" not in line:
+        return line
+
+    if talking_character and line.startswith(f"{talking_character}:"):
+        line = line[len(talking_character)+1:].lstrip()
+    
+
+    # Splitting the text into segments based on asterisks
+    segments = re.split('(\*[^*]*\*)', line)
+    formatted_line = ""
+
+    for i, segment in enumerate(segments):
+        if segment.startswith("*") and segment.endswith("*"):
+            # If the segment is an action or thought, add it as is
+            formatted_line += segment
+        else:
+            # For non-action/thought parts, trim and add quotes only if not empty and not already quoted
+            trimmed_segment = segment.strip()
+            if trimmed_segment:
+                if not (trimmed_segment.startswith('"') and trimmed_segment.endswith('"')):
+                    formatted_line += f' "{trimmed_segment}"'
+                else:
+                    formatted_line += f' {trimmed_segment}'
+
+
+    # adds spaces betwen *" and "* to make it easier to read
+    formatted_line = formatted_line.replace('*"', '* "')
+    formatted_line = formatted_line.replace('"*', '" *')
+
+    if talking_character:
+        formatted_line = f"{talking_character}: {formatted_line}"
+        
+    log.debug("mark_spoken_words", line=line, formatted_line=formatted_line)
+
+    return formatted_line.strip()  # Trim any leading/trailing whitespace
+
+
+def mark_exposition(line:str, talking_character:str=None) -> str:
+    """
+    Will loop through the string and make sure chunks outside of "" are marked with *.
+    
+    For example:
+    
+    "No, you're not wrong" sips his wine "This tastes gross." coughs "acquired taste i guess?"
+    
+    becomes
+    
+    "No, you're not wrong" *sips his wine* "This tastes gross." *coughs* "acquired taste i guess?"
+    """
+    
+    # no quotes in string, means its impossible to tell dialogue apart from exposition
+    if '"' not in line:
+        return line
+    
+    if talking_character and line.startswith(f"{talking_character}:"):
+        line = line[len(talking_character)+1:].lstrip()
+    
+    # Splitting the text into segments based on quotes
+    segments = re.split('("[^"]*")', line)
+    formatted_line = ""
+
+    for i, segment in enumerate(segments):
+        # If the segment is a spoken part (inside quotes), add it as is
+        if segment.startswith('"') and segment.endswith('"'):
+            formatted_line += segment
+        else:
+            # Split the non-spoken segment into sub-segments based on existing asterisks
+            sub_segments = re.split('(\*[^*]*\*)', segment)
+            for sub_segment in sub_segments:
+                if sub_segment.startswith("*") and sub_segment.endswith("*"):
+                    # If the sub-segment is already formatted, add it as is
+                    formatted_line += sub_segment
+                else:
+                    # Trim and add asterisks only to non-empty sub-segments
+                    trimmed_sub_segment = sub_segment.strip()
+                    if trimmed_sub_segment:
+                        formatted_line += f" *{trimmed_sub_segment}*"
+
+    # adds spaces betwen *" and "* to make it easier to read
+    formatted_line = formatted_line.replace('*"', '* "')
+    formatted_line = formatted_line.replace('"*', '" *')
+
+    if talking_character:
+        formatted_line = f"{talking_character}: {formatted_line}"
+    log.debug("mark_exposition", line=line, formatted_line=formatted_line)
+    
+    
+    return formatted_line.strip()  # Trim any leading/trailing whitespace

src/talemate/world_state.py

@@ -1,6 +1,7 @@
 from pydantic import BaseModel
 from talemate.emit import emit
 import structlog
+from typing import Union
 
 import talemate.instance as instance
 from talemate.prompts import Prompt
@@ -9,11 +10,11 @@ import talemate.automated_action as automated_action
 log = structlog.get_logger("talemate")
 
 class CharacterState(BaseModel):
-    snapshot: str = None
-    emotion: str = None
+    snapshot: Union[str, None] = None
+    emotion: Union[str, None] = None
     
 class ObjectState(BaseModel):
-    snapshot: str = None
+    snapshot: Union[str, None] = None
 
 class WorldState(BaseModel):
     
@@ -24,15 +25,15 @@ class WorldState(BaseModel):
     items: dict[str, ObjectState] = {}
     
     # location description
-    location: str = None
+    location: Union[str, None] = None
     
     @property
     def agent(self):
-        return instance.get_agent("summarizer")
+        return instance.get_agent("world_state")
     
     @property
     def pretty_json(self):
-        return self.json(indent=2)
+        return self.model_dump_json(indent=2)
     
     @property
     def as_list(self):
@@ -93,11 +94,4 @@ class WorldState(BaseModel):
                 "items": self.items,
                 "location": self.location,
             }
-        )
-        
-    
-@automated_action.register("world_state", frequency=5, call_initially=False)
-class WorldStateAction(automated_action.AutomatedAction):
-    async def action(self):
-        await self.scene.world_state.request_update()
-        return True
+        )

talemate_frontend/src/components/AIAgent.vue

@@ -11,7 +11,11 @@
                     <span class="ml-1" v-if="agent.label"> {{ agent.label }}</span>
                     <span class="ml-1" v-else> {{ agent.name }}</span>
                 </v-list-item-title>
-                <v-list-item-subtitle>{{ agent.client }}</v-list-item-subtitle>
+                <v-list-item-subtitle>
+                    {{ agent.client }}
+                </v-list-item-subtitle>
+                <v-chip class="mr-1" v-if="agent.status === 'disabled'" size="x-small">Disabled</v-chip>
+                <v-chip v-if="agent.data.experimental" color="warning" size="x-small">experimental</v-chip>
             </v-list-item>
         </v-list>
         <AgentModal :dialog="dialog" :formTitle="formTitle" @save="saveAgent" @update:dialog="updateDialog"></AgentModal>
@@ -116,6 +120,7 @@ export default {
         handleMessage(data) {
             // Handle agent_status message type
             if (data.type === 'agent_status') {
+                console.log("agents: got agent_status message", data)
                 // Find the client with the given name
                 const agent = this.state.agents.find(agent => agent.name === data.name);
                 if (agent) {
@@ -124,15 +129,27 @@ export default {
                     agent.data = data.data;
                     agent.status = data.status;
                     agent.label = data.message;
+                    agent.actions = {}
+                    for(let i in data.data.actions) {
+                        agent.actions[i] = {enabled: data.data.actions[i].enabled, config: data.data.actions[i].config};
+                    }
+                    agent.enabled = data.data.enabled;
                 } else {
                     // Add the agent to the list of agents
+                    let actions = {}
+                    for(let i in data.data.actions) {
+                        actions[i] = {enabled: data.data.actions[i].enabled, config: data.data.actions[i].config};
+                    }
                     this.state.agents.push({
                         name: data.name,
                         client: data.client,
                         status: data.status,
                         data: data.data,
                         label: data.message,
+                        actions: actions,
+                        enabled: data.data.enabled,
                     });
+                    console.log("agents: added new agent", this.state.agents[this.state.agents.length - 1], data)
                 }
                 return;
             }

talemate_frontend/src/components/AgentModal.vue

@@ -1,28 +1,53 @@
 <template>
-    <v-dialog v-model="localDialog" persistent max-width="600px">
-        <v-card>
-        <v-card-title>
-            <span class="headline">{{ formTitle }}</span>
-        </v-card-title>
-        <v-card-text>
-            <v-container>
-              <v-row>
-                  <v-col cols="6">
-                    <v-text-field v-model="agent.name" readonly label="Agent"></v-text-field>
-                  </v-col> 
-                  <v-col cols="6">
-                    <v-select v-model="agent.client" :items="agent.data.client" label="Client"></v-select>
-                  </v-col>
-              </v-row>
-            </v-container>
-        </v-card-text>
-        <v-card-actions>
-            <v-spacer></v-spacer>
-            <v-btn color="blue darken-1" text @click="close">Close</v-btn>
-            <v-btn color="blue darken-1" text @click="save">Save</v-btn>
-        </v-card-actions>
+  <v-dialog v-model="localDialog" max-width="600px">
+    <v-card>
+      <v-card-title>
+
+        <v-row>
+          <v-col cols="9">
+            <v-icon>mdi-transit-connection-variant</v-icon>
+            {{ agent.label }}
+          </v-col>
+          <v-col cols="3" class="text-right">
+            <v-checkbox :label="enabledLabel()" hide-details density="compact" color="green" v-model="agent.enabled"
+              v-if="agent.data.has_toggle"></v-checkbox>
+          </v-col>
+        </v-row>
+
+
+
+      </v-card-title>
+      <v-card-text>
+        <v-select v-model="agent.client" :items="agent.data.client" label="Client"></v-select>
+
+        <v-alert type="warning" variant="tonal" density="compact" v-if="agent.data.experimental">
+          This agent is currently experimental and may significantly decrease performance and / or require
+          strong LLMs to function properly.
+        </v-alert>
+
+        <v-card v-for="(action, key) in agent.actions" :key="key" density="compact">
+          <v-card-subtitle>
+            <v-checkbox :label="agent.data.actions[key].label" hide-details density="compact" color="green" v-model="action.enabled"></v-checkbox>
+          </v-card-subtitle>
+          <v-card-text>
+              {{ agent.data.actions[key].description }}
+              <div v-for="(action_config, config_key) in agent.data.actions[key].config" :key="config_key">
+                <!-- render config widgets based on action_config.type (int, str, bool, float) -->
+                <v-text-field v-if="action_config.type === 'str'" v-model="action.config[config_key].value" :label="action_config.label" :hint="action_config.description" density="compact"></v-text-field>
+                <v-slider v-if="action_config.type === 'number' && action_config.step !== null" v-model="action.config[config_key].value" :label="action_config.label" :hint="action_config.description" :min="action_config.min" :max="action_config.max" :step="action_config.step" density="compact" thumb-label></v-slider>
+                <v-checkbox v-if="action_config.type === 'bool'" v-model="action.config[config_key].value" :label="action_config.label" :hint="action_config.description" density="compact"></v-checkbox>
+              </div>
+          </v-card-text>
         </v-card>
-    </v-dialog>
+
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer></v-spacer>
+        <v-btn color="primary" @click="close">Close</v-btn>
+        <v-btn color="primary" @click="save">Save</v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
 </template>
   
 <script>
@@ -56,6 +81,13 @@ export default {
     }
   },
   methods: {
+    enabledLabel() {
+      if (this.agent.enabled) {
+        return 'Enabled';
+      } else {
+        return 'Disabled';
+      }
+    },
     close() {
       this.$emit('update:dialog', false);
     },

talemate_frontend/src/components/CharacterCreator.vue

@@ -104,17 +104,17 @@
 
                             <v-list>
                                 <v-list-item v-for="(question, index) in detail_questions" :key="index">
-                                    <v-list-item-title class="text-capitalize">
+                                    <div>
                                         <v-icon color="red" @click="detail_questions.splice(index, 1)">mdi-delete</v-icon>
                                         {{ question }}
-                                    </v-list-item-title>
+                                    </div>
                                 </v-list-item>
                                 <v-text-field label="Custom question" v-model="new_question" @keydown.prevent.enter="addQuestion()"></v-text-field>
                             </v-list>
                             
                             <v-list>
                                 <v-list-item v-for="(value, question) in details" :key="question">
-                                    <v-list-item-title class="text-capitalize">{{ question }}</v-list-item-title>
+                                    <v-list-item-title>{{ question }}</v-list-item-title>
                                     <v-textarea rows="1" auto-grow v-model="details[question]"></v-textarea>
                                 </v-list-item>
                             </v-list>
@@ -135,10 +135,10 @@
 
                             <v-list>
                                     <v-list-item v-for="(example, index) in dialogue_examples" :key="index">
-                                        <v-list-item-title class="text-capitalize">
+                                        <div>
                                             <v-icon color="red" @click="dialogue_examples.splice(index, 1)">mdi-delete</v-icon>
                                             {{ example }}
-                                        </v-list-item-title>
+                                        </div>
                                     </v-list-item>
                                     <v-text-field label="Add dialogue example" v-model="new_dialogue_example" @keydown.prevent.enter="addDialogueExample()"></v-text-field>
                             </v-list>
@@ -163,6 +163,7 @@
                         </v-card-actions>
                     </v-card>
                 </template>
+                <v-alert v-if="error_message !== null" type="error" variant="tonal" density="compact" class="mb-2">{{ error_message }}</v-alert>
 
             </v-stepper>
         </v-window>
@@ -218,6 +219,8 @@ export default {
             custom_attributes: {},
             new_attribute_name: "",
             new_attribute_instruction: "",
+
+            error_message: null,
         }
     },
     inject: ['getWebsocket', 'registerMessageHandler', 'setWaitingForInput', 'requestSceneAssets'],
@@ -276,6 +279,7 @@ export default {
             this.dialogue_examples = [];
             this.character = null;
             this.generating = false;
+            this.error_message = null;
         },
 
         addQuestion() {
@@ -380,6 +384,8 @@ export default {
             if(step == 4)
                 this.details = {};
 
+            this.error_message = null;
+
             this.sendRequest({
                 action: 'submit',
                 base_attributes: this.base_attributes,
@@ -422,6 +428,11 @@ export default {
             }
         },
 
+        hanldeError(error_message) {
+            this.generating = false;
+            this.error_message = error_message;
+        },
+
         handleBaseAttribute(data) {
             this.base_attributes[data.name] = data.value;
             if(data.name == "name") {
@@ -461,6 +472,8 @@ export default {
                 } else if(data.action === 'description') {
                     this.description = data.description;
                 } 
+            } else if(data.type === "error" && data.plugin === 'character_creator') {
+                this.hanldeError(data.error);
             }
         },
     },

talemate_frontend/src/components/CoverImage.vue

@@ -1,6 +1,6 @@
 <template>
     <div v-if="expanded">
-        <v-img @click="toggle()" v-if="asset_id !== null" :src="'data:'+media_type+';base64, '+base64"></v-img>
+        <v-img cover @click="toggle()" v-if="asset_id !== null" :src="'data:'+media_type+';base64, '+base64"></v-img>
     </div>
     <v-list-subheader v-else @click="toggle()"><v-icon>mdi-image-frame</v-icon> Cover image
         <v-icon v-if="expanded" icon="mdi-chevron-down"></v-icon>

talemate_frontend/src/components/SceneMessages.vue

@@ -40,6 +40,11 @@
                     <DirectorMessage :text="message.text" :message_id="message.id" :character="message.character" />
                 </div>
             </div>
+            <div v-else-if="message.type === 'time'" :class="`message ${message.type}`">
+                <div class="time-message"  :id="`message-${message.id}`">
+                    <TimePassageMessage :text="message.text" :message_id="message.id" :ts="message.ts" />
+                </div>
+            </div>
             <div v-else :class="`message ${message.type}`">
                 {{ message.text }}
             </div>
@@ -51,6 +56,7 @@
 import CharacterMessage from './CharacterMessage.vue';
 import NarratorMessage from './NarratorMessage.vue';
 import DirectorMessage from './DirectorMessage.vue';
+import TimePassageMessage from './TimePassageMessage.vue';
 
 export default {
     name: 'SceneMessages',
@@ -58,6 +64,7 @@ export default {
         CharacterMessage,
         NarratorMessage,
         DirectorMessage,
+        TimePassageMessage,
     },
     data() {
         return {
@@ -87,6 +94,7 @@ export default {
                 multiSelect: data.data.multi_select,
                 color: data.color,
                 sent: false,
+                ts: data.ts,
             };
             this.messages.push(message);
         },
@@ -163,10 +171,12 @@ export default {
             
             if (data.message) {
                 if (data.type === 'character') {
-                    const [character, text] = data.message.split(':');
+                    const parts = data.message.split(':');
+                    const character = parts.shift();
+                    const text = parts.join(':');
                     this.messages.push({ id: data.id, type: data.type, character: character.trim(), text: text.trim(), color: data.color }); // Add color property to the message
                 } else if (data.type != 'request_input' && data.type != 'client_status' && data.type != 'agent_status') {
-                    this.messages.push({ id: data.id, type: data.type, text: data.message, color: data.color, character: data.character, status:data.status }); // Add color property to the message
+                    this.messages.push({ id: data.id, type: data.type, text: data.message, color: data.color, character: data.character, status:data.status, ts:data.ts }); // Add color property to the message
                 }
             }
 

talemate_frontend/src/components/SceneTools.vue

@@ -86,6 +86,20 @@
                         </v-btn>
                     </template>
                 </v-tooltip>
+                <v-menu>
+                    <template v-slot:activator="{ props }">
+                        <v-btn class="hotkey mx-3" v-bind="props" :disabled="isInputDisabled()" color="primary" icon>
+                            <v-icon>mdi-clock</v-icon>
+                        </v-btn>
+                    </template>
+                    <v-list>
+                        <v-list-subheader>Advance Time</v-list-subheader>
+                        <v-list-item v-for="(option, index) in advanceTimeOptions" :key="index"
+                            @click="sendHotButtonMessage('!advance_time:' + option.value)">
+                            <v-list-item-title>{{ option.title }}</v-list-item-title>
+                        </v-list-item>
+                    </v-list>
+                </v-menu>
                 <v-divider vertical></v-divider>
                 <v-tooltip :disabled="isInputDisabled()" location="top" text="Direct a character">
                     <template v-slot:activator="{ props }">
@@ -142,6 +156,7 @@
         </v-card>
 
     </div>
+    
 </template>
 
 
@@ -154,6 +169,23 @@ export default {
         return {
             commandActive: false,
             commandName: null,
+
+            advanceTimeOptions: [
+                {"value" : "P10Y", "title": "10 years"},
+                {"value" : "P5Y", "title": "5 years"},
+                {"value" : "P1Y", "title": "1 year"},
+                {"value" : "P6M", "title": "6 months"},
+                {"value" : "P3M", "title": "3 months"},
+                {"value" : "P1M", "title": "1 month"},
+                {"value" : "P7D:1 Week later", "title": "1 week"},
+                {"value" : "P3D", "title": "3 days"},
+                {"value" : "P1D", "title": "1 day"},
+                {"value" : "PT8H", "title": "8 hours"},
+                {"value" : "PT4H", "title": "4 hours"},
+                {"value" : "PT1H", "title": "1 hour"},
+                {"value" : "PT30M", "title": "30 minutes"},
+                {"value" : "PT15M", "title": "15 minutes"}
+            ],
         }
     },
     inject: [

talemate_frontend/src/components/TalemateApp.vue

@@ -14,7 +14,7 @@
         <LoadScene ref="loadScene" />
         <v-divider></v-divider>
         <div :style="(sceneActive && scene.environment === 'scene' ? 'display:block' : 'display:none')">
-          <GameOptions v-if="sceneActive" ref="gameOptions" />
+          <!-- <GameOptions v-if="sceneActive" ref="gameOptions" /> -->
           <v-divider></v-divider>
           <CoverImage v-if="sceneActive" ref="coverImage" />
           <WorldState v-if="sceneActive" ref="worldState" />
@@ -97,6 +97,11 @@
         <v-btn v-if="scene.environment === 'scene'" class="ml-1" @click="openSceneHistory()"><v-icon size="14"
             class="mr-1">mdi-playlist-star</v-icon>History</v-btn>
 
+        <v-chip size="x-small" v-if="scene.scene_time !== undefined">
+          <v-icon>mdi-clock</v-icon>
+          {{ scene.scene_time }}
+        </v-chip>
+
       </v-toolbar-title>
       <v-toolbar-title v-else>
         Talemate
@@ -148,7 +153,7 @@ import LoadScene from './LoadScene.vue';
 import SceneTools from './SceneTools.vue';
 import SceneMessages from './SceneMessages.vue';
 import WorldState from './WorldState.vue';
-import GameOptions from './GameOptions.vue';
+//import GameOptions from './GameOptions.vue';
 import CoverImage from './CoverImage.vue';
 import CharacterSheet from './CharacterSheet.vue';
 import SceneHistory from './SceneHistory.vue';
@@ -164,7 +169,7 @@ export default {
     SceneTools,
     SceneMessages,
     WorldState,
-    GameOptions,
+    //GameOptions,
     CoverImage,
     CharacterSheet,
     SceneHistory,
@@ -294,6 +299,7 @@ export default {
         this.scene = {
           name: data.name,
           environment: data.data.environment,
+          scene_time: data.data.scene_time,
         }
         this.sceneActive = true;
         return;

talemate_frontend/src/components/TimePassageMessage.vue

@@ -0,0 +1,61 @@
+<template>
+  <div class="time-container" v-if="show && minimized" >
+    <v-chip closable @click:close="deleteMessage()" color="deep-purple-lighten-3">
+      <v-icon class="mr-2">mdi-clock-outline</v-icon>
+      <span>{{ text }}</span>
+    </v-chip>
+  </div>
+</template>
+  
+<script>
+export default {
+  data() {
+    return {
+      show: true,
+      minimized: true
+    }
+  },
+  props: ['text', 'message_id', 'ts'],
+  inject: ['requestDeleteMessage'],
+  methods: {
+    toggle() {
+      this.minimized = !this.minimized;
+    },
+    deleteMessage() {
+      console.log('deleteMessage', this.message_id);
+      this.requestDeleteMessage(this.message_id);
+    }
+  }
+}
+</script>
+  
+<style scoped>
+.highlight {
+  color: #9FA8DA;
+  font-style: italic;
+  margin-left: 2px;
+  margin-right: 2px;
+}
+
+.highlight:before {
+  --content: "*";
+}
+
+.highlight:after {
+  --content: "*";
+}
+
+.time-text {
+  color: #9FA8DA;
+}
+
+.time-message {
+  display: flex;
+  flex-direction: row;
+  color: #9FA8DA;
+}
+
+.time-container {
+  
+}
+</style>

talemate_frontend/src/components/WorldState.vue

@@ -34,6 +34,12 @@
 
                             </template>
                         </v-tooltip>
+                        <v-tooltip v-else text="Make this character real, adding it to the scene as an actor.">
+                            <template v-slot:activator="{ props }">
+                                <v-btn size="x-small" class="mr-1" v-bind="props" variant="tonal" density="comfortable" rounded="sm" @click.stop="persistCharacter(name)" icon="mdi-chat-plus-outline"></v-btn>
+
+                            </template>
+                        </v-tooltip>
                     </div>
                     <v-divider class="mt-1"></v-divider>
                 </v-expansion-panel-text>
@@ -97,6 +103,12 @@ export default {
                 text: `!narrate_c:${name}`,
             }));
         },
+        persistCharacter(name) {
+            this.getWebsocket().send(JSON.stringify({
+                type: 'interact',
+                text: `!pc:${name}`,
+            }));
+        },
         lookAtItem(name) {
             this.getWebsocket().send(JSON.stringify({
                 type: 'interact',

templates/llm-prompt/Airoboros.jinja2

@@ -1,2 +1,2 @@
 SYSTEM: {{ system_message }}
-USER: {{ set_response(prompt, "\nASSISTANT:") }}
+USER: {{ set_response(prompt, "\nASSISTANT: ") }}

templates/llm-prompt/Alpaca.jinja2

@@ -0,0 +1,4 @@
+{{ system_message }}
+
+### Instruction:
+{{ set_response(prompt, "\n\n### Response:\n") }}

templates/llm-prompt/Amethyst-20B.jinja2

@@ -0,0 +1,4 @@
+{{ system_message }}
+
+### Instruction:
+{{ set_response(prompt, "\n\n### Response:\n") }}

templates/llm-prompt/Amethyst.jinja2

@@ -0,0 +1,4 @@
+{{ system_message }}
+
+### Instruction:
+{{ set_response(prompt, "\n\n### Response:\n") }}

templates/llm-prompt/CausalLM.jinja2

@@ -0,0 +1,4 @@
+<|im_start|>system
+{{ system_message }}<|im_end|>
+<|im_start|>user
+{{ set_response(prompt, "<|im_end|>\n<|im_start|>assistant\n") }}

templates/llm-prompt/ChatLM.jinja2

@@ -0,0 +1,4 @@
+<|im_start|>system
+{{ system_message }}<|im_end|>
+<|im_start|>user
+{{ set_response(prompt, "<|im_end|>\n<|im_start|>assistant\n") }}

templates/llm-prompt/OpenHermes-2-Mistral-7B.jinja2

@@ -0,0 +1,4 @@
+<|im_start|>system
+{{ system_message }}<|im_end|>
+<|im_start|>user
+{{ set_response(prompt, "<|im_end|>\n<|im_start|>assistant\n") }}

templates/llm-prompt/Speechless-Llama2-Hermes-Orca-Platypus-WizardLM.jinja2

@@ -0,0 +1,4 @@
+{{ system_message }}
+
+### Instruction:
+{{ set_response(prompt, "\n\n### Response:\n") }}

templates/llm-prompt/SynthIA.jinja2

@@ -0,0 +1,2 @@
+SYSTEM: {{ system_message }}
+USER: {{ set_response(prompt, "\nASSISTANT: ") }}

templates/llm-prompt/Tiefighter.jinja2

@@ -0,0 +1,4 @@
+{{ system_message }}
+
+### Instruction:
+{{ set_response(prompt, "\n\n### Response:\n") }}

templates/llm-prompt/Vicuna.jinja2

@@ -1,2 +1,2 @@
 SYSTEM: {{ system_message }}
-USER: {{ set_response(prompt, "\nASSISTANT:") }}
+USER: {{ set_response(prompt, "\nASSISTANT: ") }}

templates/llm-prompt/Xwin-LM.jinja2

@@ -1 +1,2 @@
-{{ system_message }} USER: {{ set_response(prompt, " ASSISTANT:") }}
+{{ system_message }}
+USER: {{ set_response(prompt, "\nASSISTANT: ") }}

templates/llm-prompt/Xwin-MLewd.jinja2

@@ -0,0 +1,4 @@
+{{ system_message }}
+
+### Instruction:
+{{ set_response(prompt, "\n\n### Response:\n") }}

templates/llm-prompt/Zephyr.jinja2

@@ -0,0 +1,4 @@
+<|system|>
+{{ system_message }}</s>
+<|user|>
+{{ set_response(prompt, "</s>\n<|assistant|>\n") }}

templates/llm-prompt/dolphin-2.1-mistral.jinja2

@@ -0,0 +1,4 @@
+<|im_start|>system
+{{ system_message }}<|im_end|>
+<|im_start|>user
+{{ set_response(prompt, "<|im_end|>\n<|im_start|>assistant\n") }}