Skip to content

v0.8.0

This release is about characters that remember and characters you can watch talk. A new Summarize node folds old turns into a rolling summary, so a long conversation keeps its thread instead of being trimmed away. Experimental mutable knowledge bases let an agent write what it learns into a named store, retrieve it later, and save it with the game. A server-side viseme track drives lip sync on ARKit faces in Unity and Unreal, and on MetaHumans. Voice turns are now sent by your client, hotword biasing works on the models that support it, and Japanese, Chinese and other scripts that put no space after a full stop now start speaking mid-answer. The server also gains deployment modes, one process-wide storage root, and a user model catalog that survives updates.

Voice input, intent events, storage folders, model management and node parameter validation all changed, and the schema changed. See Breaking changes and behavior changes before upgrading.

Highlights

  • Long conversations stay coherent. Put a Summarize node last in a graph. Turns older than a hot window are folded into a rolling summary that every generating node reads. The cost per turn stays fixed, and nothing the player said is silently trimmed. See Keep long conversations coherent.
  • Agents that write their own memory (experimental). Named, session-scoped knowledge bases that a graph writes with WriteToMemory and reads with Retrieve. Your client can query and edit them, and they save with the game. A Knowledge window in both editors lets you inspect them.
  • Lip sync. emit_visemes on GenerateAndSpeak streams a viseme track aligned to the audio. TryllLipSync (Unity) and Tryll Lip Sync (Unreal) play it on ARKit blendshapes, and a separate plugin drives MetaHuman faces. See Add lip sync to a character and Add lip sync to a MetaHuman.
  • Hotwords that actually bias recognition. A per-model Hotword biasing switch, per-phrase scores, and a clear list of the STT models that support it. A lexicon given to a model with biasing turned off now fails with an error instead of doing nothing. See Bias voice input with hotwords.
  • Speech starts sooner, in more languages. Sentence ends in CJK, Devanagari, Arabic, Urdu and Ethiopic scripts now close a TTS chunk. Before this, a Chinese or Japanese reply stayed silent until the model had finished writing. The new first_chunk_max_chars parameter shortens the wait for the first audio on any voice.
  • Add your own models without editing the shipped catalog. Point the project at a user catalog file and it survives every Tryll update. A broken user catalog is skipped instead of stopping the server. See Use your own local model.
  • Deployment modes and one storage root. The server runs as Tryll Dev, Client Dev or Client Prod, and storage, models, logs and saves each resolve from one process-wide root. Unity and Unreal keep that content in <Project>/TryllStorage/, outside Assets/ and Content/. See Server configuration.
  • Per-NPC events. Tool-call, intent, pause and node events now fire on the agent itself, so each NPC can listen for its own events without filtering by agent id.

Long conversations

  • New Summarize node. Place it last in a graph. When trigger_tokens (default 1024) or trigger_turns is crossed, it folds every interaction older than keep_recent_turns (default 3) into a summary of at most max_summary_tokens (default 256). Every Generate-class node in the agent then renders that summary as untrusted dialogue data and replays history only from the fold boundary. A large backlog is folded in chronological chunks.
  • It runs beside the character, not as the character. The node uses its own context (context_size 0 resolves to 2048) on the agent's default model and an instruction-only prompt, never the persona. It never emits answer text. Summary tokens count toward TurnComplete.tokens_generated. system_prompt and template are overridable, and set notify_client for a summarized event.
  • The summary is part of the dialog snapshot. ExportDialog / ImportDialog carry it, so a saved conversation resumes with its summary intact. Turn diagnostics record each fold, or the reason one was skipped.
  • Keep long conversations coherent walks through choosing the trigger and the hot window. Projection and token budgets explains where the summary sits in the prompt.

Memory and saves (experimental)

  • Named mutable knowledge bases. EnsureMutableKb gets or creates a session-scoped store under a schema registered in data/schemas.json. The handle writes, deletes, clears, queries, lists, reports stats, and exports or imports one store. C++, Python, Unity and Unreal all ship handles. Every write is embedded straight away, so the first write to a new store and eager loads are slow.
  • WriteToMemory upserts from a graph. It writes its input slot to storage_name, with an optional per-turn id template, and exits written or failed. Empty input is a no-op that still exits written. Put a Retrieve before the write if the model should see what was already there.
  • Retrieve reads a named store. Set source_kind to name mode and give storage_name and schema in place of embedded_string_storage. {{var.npc_id}}-style store names resolve at agent creation, which is how each NPC gets its own memory from one shared graph. Unity's [TryllSchema] picker lists the registered schemas. See Retrieve.
  • Game memory and dialog files. SaveGameMemory / LoadGameMemory write and read every store at once as a text-only TMKB file, and vectors are rebuilt on load. LoadGameMemory takes an explicit Now or Lazy embed timing. SaveDialog / LoadDialog write dialog to a file and carry your save_id. A later load warns when the memory and dialog files came from different saves. See Save and load agent state.
  • The process owns where saves land. Save paths resolve through the server's saves settings (enabled, root, allow_absolute_paths) or --disable-saves / --save-root / --allow-absolute-save-paths. A relative path joins saves.root, or the storage root if no save root is set. Unity and Unreal auto-launch allow absolute paths, and a player build passes persistentDataPath / ProjectSavedDir() as the save root (or Save Data Folder from Project Settings). See Server configuration.
  • A Knowledge window in both editors. Window ▸ Tryll ▸ Knowledge (Unity) and Window ▸ Tryll ▸ Tryll Knowledge (Unreal) show stores on the left (with ensure and session save/load), records in the middle (Filter or Query), and write, delete, clear and per-store TMKB export/import on the right.

Lip sync

Superseded

Superseded in v0.9.0: emit_visemes moved to the agent's voice profile, and Speak nodes now emit visemes too.

  • emit_visemes on GenerateAndSpeak. Off by default and mutable. When on, the node sends one viseme event per synthesized sentence: 15 Oculus visemes timed in samples from the start of that node's audio. Speak does not emit visemes. See TTS and voice output.
  • Unity: TryllLipSync. Add it next to a TryllSpeaker and it drives ARKit blendshapes from the viseme track against the speaker's playback clock, compensating for output latency. It exposes Intensity, smoothing and attack/decay, BindFace(), and live status for debugging. TryllAgent.OnTtsVisemes exposes the raw events. See TryllLipSync.
  • Unreal: Tryll Lip Sync component. UTryllLipSyncComponent drives ARKit morph targets on non-MetaHuman faces. It has Blueprint-callable SetIntensity and BindFace, and pose and settings structs you can author. The speaker gains GetOutputLatencyMs and OnTtsVisemes. See the Blueprint catalog.
  • MetaHuman lip sync (Unreal, separate plugin). TryllMetaHumanLipSync drives a MetaHuman face either from Epic's realtime speech-to-animation model (Neural, the default) or from Tryll's viseme track (Viseme). It is off by default, and it needs a one-time Set Up in Project Settings before Play or packaging will run. See Add lip sync to a MetaHuman.
  • C++ and Python receive the same events through SetOnTtsVisemes / set_on_tts_visemes (TtsVisemeEvent).
  • The Agent Log shows the voice track. TTS format and TTS visemes rows appear in the timeline beside the text. See Use the Agent Log.

Voice output

  • Sentence splitting understands more scripts. CJK, Devanagari, Arabic, Urdu and Ethiopic sentence ends close a chunk without a following space, and closing quotes stay with their sentence. … counts as a full stop. min_sentence_chars is now a width: a CJK character counts as two, so the default of 12 is about six CJK characters. A number such as 3.14 is no longer split after the 3.. Text that never ends a sentence is cut at a 16 KiB cap, with a warning.
  • first_chunk_max_chars on GenerateAndSpeak and Speak. Default 0 (off). When set, only the first chunk may also end at a comma, semicolon, colon or em dash, and it is cut at the next space once it reaches that width. It never cuts before 5 words or min_sentence_chars. 48 reduced the model-side wait before the first audio by about 40% in our measurements. Listen to it with your own voice first, because a clause can end on a falling tone. See Speak and Generate and Speak.
  • Raw PCM for your own audio pipeline. TryllSpeaker.OnTtsPcm (Unity) and UTryllSpeakerComponent::OnTtsPcm (Unreal) hand you every decoded buffer, for example to feed your own spatializer. The Unity speaker also exposes OnTtsFormat, ConsumedSamples and QueuedSamples. See TryllSpeaker.
  • Unity speaker fixes. A TryllAgentComponent with an empty Speaker slot now reuses the TryllSpeaker already on the GameObject instead of adding a second one, which also left a lip-sync component following a silent speaker. A speaker that is disabled and re-enabled now plays again.
  • speed is checked the same way at creation and at runtime. ChangeAgentParam now enforces the 0.1–3.0 range too, as CreateAgent already did.

Voice input

  • Your client sends the voice turn. The server now only transcribes. On UtteranceFinal, send the text yourself with SendText, send_message_async, or the agent component's SendMessage. Unity and Unreal voice components do this for you when a target agent is set, and drop the final if that agent already has a turn in flight. In Python, use send_message_async from the transcript callback, because the blocking send_message deadlocks on the reader thread. See Use voice input.
  • Hotword biasing you can switch per model. The Model Manager has a Hotword biasing control (Default / Off / On) on STT models. In code, pass hotword_hints (Python) or placementHints with .hotwords (C++) to CreateSession. The shipped catalog turns biasing on for Parakeet TDT 0.6B v3.
  • Better lexicons. Write plain words, one phrase per line. Append :<score> to boost a single phrase. Pretokenized lexicons still work. The default hotwordsScore stays 1.5, and the guide's recommended ranges moved up. Transducer and streaming Zipformer models support hotwords, but CTC-family models do not. An unsupported model now logs a warning at voice-input creation instead of ignoring the lexicon silently. See Bias voice input with hotwords.
  • Unity voice component sets hotwords. TryllVoiceInputComponent gains hotwordsStoragePath (a Storage Data Folder file picker; leave it empty to disable) and hotwordsScore. See TryllVoiceInputComponent.

Intent classification

  • ClassifyIntentLLM takes an intents array. Author id/prompt pairs as entries (ClassifyIntentEntry in Python, TryllClassifyIntentEntry in Unity, FTryllClassifyIntentEntry in Unreal), so a description can contain a comma. The comma-separated intents_ids / intents_prompt pair is deprecated and kept for one release. If intents is empty, the node falls back to it. Setting both is a graph-creation error. Unreal binary assets were not migrated, so copy the values out of the inspector to use the array. See Classify Intent (LLM).
  • The classifier prompt is checked up front. system_prompt must be a Mustache template that parses and references {{intents_block}}. Otherwise CreateAgent and ChangeAgentParam fail, where previously the template was sent anyway and classification quietly broke. {{letters}} is now optional. See Design an intent-classifier prompt.

Tool calling

  • Tool Call diagnostics say why a parse failed. When output.parse_fallback is true, output.parse_failure reports whether the model attempted a call and got the syntax wrong (malformed_call), answered in prose (no_call), or used a chat template that declares no call marker to check against (unclassified). output.parse_error gives the parser's reason and the byte where it stopped. The Unity and Unreal turn inspectors show both under the parse-fallback chip. See Tool Call diagnostics.
  • Fix tool-call text in answers. What to check when a reply shows raw tool-call markup such as <|tool_call>… instead of dialogue: a speech node told to call a tool on a turn that skipped ToolCall, an unparsed call sent under mode = call_or_answer, or leaked replies replaying from history.
  • Unity: async tool handlers. RegisterTool on TryllAgent / TryllAgentComponent accepts Func<TryllToolCall, Task<string>>. The paused batch is held until every handler completes on the main thread, and results that already succeeded are kept across a retry. Synchronous handlers are unaffected.
  • Dialog Lab treats a tool-call mismatch as a check failure. A missing, unexpected or wrong-name call now completes the turn as an amber CheckFail with its diagnostics, and the rest of the script keeps running. See Test tool calls in Chat and the Lab.

Retrieval

  • Query rewriting and HyDE for RAG. A second rewrite recipe writes a short hypothetical passage instead of a keyword query (HyDE). It works better when your knowledge base stores statements rather than questions. The page includes a table for choosing between the two recipes by how your chunks are written, and advice on re-checking threshold and keeping a Keywords: line for Hybrid retrieval.

Models and catalogs

  • User model catalog. Set Project Settings → Tryll Client → Custom Models → Catalog (Unity) or Project Settings → Plugins → Tryll Client → Models (Unreal) to a JSON file inside the project. You can also call TrySetUserModelsCatalogPath / SetUserModelsCatalogPath before the server launches. Setting it while an auto-launched server is running restarts that server. A packaged game stages the file under Server/data/user-catalog/, with relative chat templates beside it. A standalone server takes user_models_catalog_path / --user-models-path or a models.d folder (--user-models-dir), and tryll_server --check-catalogs validates them. A broken user file is skipped, and a duplicate name loses to the shipped entry. See Use your own local model and Model Management.
  • Runtime model management is explicit. When a model must be acquired: call RequestDownloadModel, wait for a successful OnDownloadComplete, then call RequestLoadModel. Call RequestLoadModel alone to pin a model that is already staged, or create the agent and let the server load on demand. See Pin and unpin models.
  • A broken models.json stops the server. A missing file, a parse error, or the retired device_preference key now exits the server with an error, the same way a broken server-config.json already did. Before, it logged a warning and served an empty catalog.

Server, storage and deployment

  • Deployment modes. --mode (or the mode key) selects tryll-dev, client-dev or client-prod. The mode sets the default roots, the log file, whether models can be downloaded, and which developer features run. The monitor, debug commands and STT debug dumps work only in Tryll Dev. Client Dev and Client Prod refuse to start without a config file. Unity and Unreal auto-launch the server in Client Dev. See Run the Tryll server and Server configuration.
  • One storage root per process. Relative storage paths resolve against --storage-root / storage_root, or the mode's default. Models and logs follow --models-root / models_root and --log-dir / logs_dir. The session no longer carries a storage folder, and ConnectionReady reports the server's mode.
  • TryllStorage in Unity and Unreal. Storage defaults to <Project>/TryllStorage/, outside the engine asset folders. Unity copies it into StreamingAssets/Tryll/ in the build output. Unreal stages it next to the packaged project, so you no longer need Additional Non-Asset Directories to Copy. See Ship storage folders for builds.
  • Client Dev logs per project. Each run writes one log file under %LOCALAPPDATA%\Tryll\projects\<project-key>\logs\, not inside the plugin package. The deployment mode, not log_mode, now picks the file name: a per-run tryll_<timestamp>.log in Tryll Dev and Client Dev, a rotating tryll.log in Client Prod. Crash dumps always go to the logs folder.
  • Usage telemetry in Client Dev. Host ID, hardware inventory and session-started events always send in Client Dev. Activity telemetry is a separate lane (activity_enabled, default true). See Telemetry.

Client APIs

  • Events per agent. Unity TryllAgent / TryllAgentComponent and Unreal UTryllAgentComponent raise tool-call, intent, pause and generic node events for that agent only, with the payload alone (ToolCallDetailed, IntentClassified, IntentLlmClassified, Paused, NodeEvent and the tool-call variants in Unity, and their On… counterparts in Unreal). Bind these when you care about one NPC. The session events remain the all-agents surface. A typed listener suppresses only its own scope's generic NodeEvent. See TryllAgentComponent and the Blueprint catalog.
  • Unity: code-created agents receive their own answers. TryllAgent has public SetOnAnswerText, SetOnTurnComplete, SetOnError, SetOnTtsAudioFormat and SetOnTtsAudio, matching C++, Unreal and Python. Register them before SendMessage, and pass null to clear. TryllSpeaker.HandleFormat / HandleAudio are public, so you can wire playback without a component. See TryllAgent.
  • Unity and Unreal error enums list every server code. TryllErrorCode / ETryllErrorCode are now generated from the server's list, so new codes appear without a client release lagging behind.
  • Unity/Unreal: an oversized request fails on its own. A command too large to send now fails that request with 5003 FrameTooLarge (or 3021 DialogSnapshotTooLarge for a dialog import), and the connection stays up.
  • Unity/Unreal: an empty send is not a turn. SendMessage("") does nothing, so a leftover empty string never reaches the server as a malformed request.
  • Unreal plugin builds on UE 5.8 as well as 5.7. Play-in-Editor still waits for the model check and resumes when it passes.
  • Play-in-Editor pause warning. If no OnPaused is bound, a pause nothing can resume now logs its warning in PIE, and the subsystem's OnNodeEvent receives paused events. Previously the editor's own subscription hid both.

Agentic coding

  • Agentic coding with Tryll. How to have an AI coding agent build Tryll agents: AGENTS.md, and prompt advice from real runs.
  • Tryll MCP plugin (Unreal 5.8). A separate TryllMCP plugin, off by default, gives an AI coding agent four tools through the Unreal editor's MCP server: describe node types, and validate, write and read a whole workflow asset. It requires Epic's experimental Model Context Protocol and Toolset Registry plugins.

Editor

  • Chat voice input is one menu. Off, Chat (Chat owns speech-to-text) or Actor component. Unity drives the scene TryllVoiceInputComponent in Play Mode. Unreal copies that component's STT model, VAD and hotwords into Chat's own handle, so it works without PIE. Unity push-to-talk with a Voice Component no longer sticks, and a quick release no longer starts the microphone after the utterance has ended. See Test an agent in the editor.
  • One status bar and banner across every window. Chat, Model Manager, Memory, Dialog Lab, Agent Log and Knowledge show connection state the same way. A dropped connection or failed session offers Retry. Failed model loads, unloads, downloads and Dialog Lab import errors appear on an inline banner. Destructive confirms stay as dialogs.
  • Windows follow the host editor theme, including Unity's light skin. Chat bubbles match Dialog Lab, and status colours are the same in every window.
  • Layouts persist. Inspector and list widths, the Model Manager columns (now resizable), and the Unity Dialog Lab and Agent Log settings survive an editor restart and stay with the project. Collapsing an inspector no longer saves a zero width or leaves a gap.
  • Chat and Agent Log follow the tail only when you are near the bottom, so scrolling up mid-stream no longer jumps back on every token.
  • Model Manager opens even when registered models are missing. It lists the catalog first, then prompts you to download.
  • Fixes. Restoring several Tryll windows at once no longer wedges Chat on a duplicate session. The Unity Memory and Agent Log windows no longer throw on editor start. Entering Play in Unity with an editor window connected now logs a reconnect warning instead of a socket-thread crash. Dialog Lab per-variant agents keep their assignment across a scene unload. Unreal icons that rendered as empty boxes are fixed.
  • The Unreal TryllUnrealDemo project packages again after the editor saves it. Its .uproject description had a non-ASCII dash. When the editor rewrote the file, which it does on its own or on an engine-version switch, it saved it as UTF-16. UnrealBuildTool then failed on byte 0 with JsonReaderException: '0xFF' is an invalid start of a value, and packaging and project-file generation both stopped. The descriptor is now ASCII-only. A copy from an earlier release that already shows this error needs re-saving as UTF-8 without a BOM, in any text editor. A version-switch copy can also be left with an engine GUID in EngineAssociation; set it back to your version, such as "5.8". Keep your own .uproject and .uplugin text ASCII-only for the same reason.

Documentation

  • Tryll in Ten Minutes is the new starting point: what Tryll is, why it runs on the player's machine, agents as workflows, the building blocks, and how a team works with it. Architecture at a Glance becomes the engineer's view.
  • Docs are versioned. Each minor release is published under /vX.Y/ with a version switcher. The plugin version is in package.json, the .uplugin, or AGENTS.md.
  • Samples compile against the current API. Every CreateSession sample is free of the engine arguments that v0.7.0 removed, and the C++, Python, Unity and Unreal graph samples use the real builder and parameter types.
  • Corrections that may change how you integrate. The code did not change in these cases; the earlier docs were wrong:
    • Speak voices its input slot, which defaults to user_message. It does not voice the last answer. Behind a Generate, set input to that node's output.
    • A ToolCall pause times out after 2000 ms by default, inherited from the shipped workflow.tool_call_pause_timeout_ms, and the turn ends with PauseTimedOut. Set pause_timeout_ms if your tool handlers are slow.
    • An exit that names a missing node fails with 3003 GraphCompilationFailed, not 3008. An empty exit is valid and ends the turn.
    • An unknown or missing model in a graph fails CreateAgent with 3003, not 4002. A second SendMessage during a live turn returns 3004 AgentBusy.
    • tts_voice is rejected, not ignored, on every voice except Pocket TTS.
    • Unloading a model drops its pin straight away, but the model stays resident until every agent using it is destroyed.
    • A streamed answer ends with an empty terminator frame (is_final = true, text = ""), so a handler that prints the final chunk prints an empty line.
    • duration_s in turn diagnostics includes paused time. Subtract paused_duration_s to get running time.
    • The Python client needs Python 3.11 or later.

Breaking changes and behavior changes

Superseded

Partly superseded. Packaged Unity and Unreal players now launch the Client Prod server with --mode client-prod and send no telemetry. --disable-telemetry is gone and include_user_content is ignored; see Telemetry for current behavior.

  • The schema changed — rebuild every client. Voice input, the TTS and classifier nodes, the new Summarize, WriteToMemory and lip-sync messages, mutable knowledge bases, and session setup all changed shape. Rebuild your integration against the new schema and upgrade both ends together. Mismatched peers fail at connect: the client rejects the server's protocol version with 5004 ProtocolVersionMismatch. See Wire Protocol.
  • Packaged games are not yet shippable to players. Unity and Unreal player builds still launch the server in Client Dev until a Client Prod build exists, and Client Dev always sends usage telemetry (see below). Do not ship those builds to end users.
  • Client Dev usage telemetry cannot be turned off. telemetry.enabled = false does not stop the usage lane in Client Dev. The server keeps it on and warns. True opt-out exists only in Tryll Dev (--disable-telemetry, or TRYLL_SERVER_MODE=tryll-dev for an auto-launched server). include_user_content now defaults to true (was false). It applies only to activity events, so set it to false if slot text and tool arguments must not leave the machine. See Telemetry.
  • Voice turns are client-sent. BeginUtterance no longer takes an agent id, and the server no longer starts a turn from a transcript. Send UtteranceFinal text yourself (see Voice input). A busy rejection is now an AgentBusy error only, with no TurnComplete after it.
  • vad_min_silence_ms defaults to 1000 (was 500). This applies when the field is omitted, and in Unity TryllVoiceInputComponent.vadMinSilenceMs. Speech now needs a longer pause before a segment closes. Set it back to 500 if you depended on the faster cut.
  • A lexicon on a model with hotword biasing off is refused with 4106 HotwordBiasDisabled instead of being ignored. CTC-family STT models are no longer described as supporting hotwords.
  • Stricter node parameters. Schema ranges and enums are enforced at agent creation and on mutation. A graph that used to load with an out-of-range value now fails with 3003 GraphCompilationFailed, and an out-of-range ChangeAgentParam returns 3007 InvalidParamValue. sampling.max_tokens is fixed at creation (3006 ParamNotMutable). It defaults to 758 and must be at least 1 and less than the node's context size. A failed string_storage or retrieve/classify filter rebind returns 3007 and leaves the previous value in force. threshold on Retrieve and ClassifyIntent accepts a cosine distance up to 2.
  • ClassifyIntentLLM.system_prompt must reference {{intents_block}}. An empty, unparsable or incomplete template now fails CreateAgent and ChangeAgentParam. Its parameter order also changed (system_prompt, intents_ids, intents_prompt, intents). Unity and Unreal assets load by name and are unaffected.
  • Intent payloads no longer carry the agent id. Unity TryllClient.IntentClassified and IntentLlmClassified are now Action<ulong, T>, called with (agentId, classification), which matches Unreal's session delegates. AgentId is removed from TryllIntentClassification, TryllIntentLlmClassification, FTryllIntentClassification and FTryllIntentLlmClassification.
  • The storage folder is process-wide. CreateSession no longer takes a storage data folder, and relative paths resolve against the server's storage root. Unity and Unreal default to <Project>/TryllStorage/, and a storage path under Assets/ or Content/ is rejected. Move existing storage content there. See Ship storage folders for builds.
  • Config and CLI removals, with no aliases. models_download_dir is replaced by models_root. crash_dump.dir and --crash-dump-dir are gone, and crash dumps always use the logs folder (logs_dir / --log-dir). log_mode no longer chooses the log file name. The committed server-config.json sets no root keys.
  • local_path must be inside the storage root. A catalog variants[].local_path that resolves outside the process storage root is ignored with a warning, so the old C:/models-style example no longer loads. Use a relative path such as "LocalModels". Client Prod ignores local_path entirely. Every variant of a model must now name the same engine.
  • Runtime model helpers removed. Unreal UTryllSubsystem::RequestModel and OnModelReady are removed. Replace them with the explicit download / load sequence under Models and catalogs; Blueprint graphs need the node and event replaced by hand. Unity TryllClient.RequestDeleteModel / DeleteModelComplete are no longer public, so delete downloaded files from Window ▸ Tryll ▸ Model Manager.
  • Unreal TryllVoiceInputComponent.bWaitForAgentReady is removed. Voice input is now created as soon as the session is ready. If you relied on the delay, set bCreateOnConnect to false and call CreateVoiceInput() from the agent's OnAgentReady.
  • A dialog snapshot written after a fold cannot be imported by an older server. It fails there with 3022 DialogUnsupportedComponent. Snapshots from agents that never summarized are unaffected, and this release reads every older snapshot.
  • A broken models.json stops the server instead of starting with an empty catalog.

New error codes

  • 4106 HotwordBiasDisabled — a voice input supplied a hotwords lexicon for a model on which this session turned hotword biasing off.
  • 4107 InvalidHotwordsScore — hotwords_score is not a finite, non-negative number.
  • 6009 ModelManagementDisabled — DownloadModel or DeleteModel in a deployment mode that does not manage models (Client Prod). Ship every model with the game.
  • 8101 StorageBusy — a mutable-KB export, import, save or load was refused because an agent is not strictly idle.
  • 8102 SchemaMismatch — the store already exists under a different schema.
  • 8103 MaxRecordsExceeded — the schema's max_records cap is reached.
  • 8104 UnknownSchema — the schema name is not in schemas.json, or that file failed to load.
  • 8105 MutableKbSnapshotInvalid — the TMKB snapshot is malformed, missing fields, or has an unsupported format version.
  • 8106 StorageSnapshotTooLarge — a store or game-memory snapshot exceeds its size cap.
  • 8107 InvalidEmbedTiming — LoadGameMemory was called without Now or Lazy.
  • 8108 UnknownMutableKb — the named store does not exist. Call EnsureMutableKb first.
  • 8109 SavesDisabled — SaveGameMemory / SaveDialog refused because saves are disabled for this process. Loads still work.

See Error Codes for the full list.