llmz 1.0.1 → 1.0.2

package/DOCS.md

@@ -138,10 +138,12 @@ console.log(restored.status) // pending
 
 Restoration checks format versions, chronology, identities, call/result pairing, exact result encodings, and memory capacity. Unknown versions are rejected. Conversation/provider fields must be acyclic JSON data; encode binary values explicitly. This is conversation and memory persistence, not a paused JavaScript stack.
 
-After a failed execution, the session retains the active input batch and any completed effects/results. Executing it again continues that turn. Newly appended messages remain queued. Applications should inspect failures before retrying operations that produce external effects.
+After a failed execution, the session retains the active input batch and any completed effects/results. Executing it again continues that turn. Newly appended messages remain queued. A successful retry can therefore leave `session.status === "pending"`; call `execute()` again to process that next batch. Its user messages reset the chat response guard when the next turn starts. Applications should inspect failures before retrying operations that produce external effects.
 
 `result.toJSON()` is a compact outcome summary. `result.diagnostics()` exports run diagnostics. Neither replaces `session.toJSON()`.
 
+Chat requires the assistant to be the last participant who spoke before `exit("listen")` can complete. Successfully delivered text and components count across iterations, executions, and saved sessions. A new user message requires a new response; events, tool results, failed deliveries, and whitespace-only content do not change the last speaker. An empty or whitespace-only model response with `stopReason: "stop"` and no tool calls follows the same listen flow and guard. Silent completion raises a recoverable `MissingChatResponseError` before `onExit`, preserving tool results for the next attempt. Set `options: { requireChatResponse: false }` for intentionally silent handling. Custom task exits and worker mode are unaffected. Older session snapshots without delivery tracking restore with an unknown last speaker and require a response by default.
+
 ## Tools and exits
 
 A `Tool` has a name, async handler, optional description, input/output schemas, aliases, metadata, and retry callback. Its original input schema validates and normalizes arguments before the handler runs. Its output schema describes likely returned data for TypeScript and the model: results are never validated, normalized, stripped, or rejected against that schema. Dynamic tools, objects, exits, instructions, and model configuration can be supplied as getters evaluated for each iteration.
@@ -177,7 +179,9 @@ Model-facing schemas describe accepted input shapes, not arbitrary JavaScript be
 
 Use `result.is(done)` to narrow the result and its output type. `result.isError()` exposes an execution failure. Without custom exits, workers receive `DefaultExit`. An explicit empty `exits` array supplies no completion exits. Chat adds `ListenExit`; an accepted plain assistant answer can complete the chat turn.
 
-Tools return business data. Generated code sends rich messages through registered `chat.<component>(props)` methods. A `ThinkSignal` requests another reasoning iteration; it is not durable pause/resume.
+Tools return business data. Generated code sends rich messages through registered `chat.<component>(props)` methods. A tool may throw or return `new ThinkSignal(reason, context)` to require inspection of a successful result. JavaScript receives `context` as the tool return value: assignments, subsequent calls, and awaited parallel tools continue normally. At the end of that iteration, inspection takes precedence over an attempted exit or a later recoverable error; exit hooks do not run. The next model turn receives every signaling tool's name, source line, reason, and result together inside `<forced_inspection>`, and is instructed to reuse those results rather than repeat successful calls. Explicit `inspect()` output is also preserved. Tool-result display budgets and `truncate()` policies still apply. Only the business tool handler may produce a `ThinkSignal`; tool hooks must return their documented input/output overrides. Forced inspection uses the output accepted by `onAfterTool`. If that hook rejects or cancels, the rejected result is withheld from guest memory and inspection.
+
+Forced inspection delays completion, not business actions: code after a signaling tool still runs, including other tools and chat component deliveries. It is not an authorization barrier. Cancellation and critical failures still stop execution completely. `ThinkSignal` is not durable pause/resume.
 
 ## Components
 
@@ -208,7 +212,7 @@ The model calls `chat.cards(...)`. `render` parses props once and captures an im
 
 `response.onDelta` receives previews. Its normal event has `delta`, accumulated `content`, `id`, and `iterationId`. A restart event has `restart: true`, an iteration ID, attempt number, models, and reason. Retract the prior preview before displaying replacement text.
 
-`response.handler` receives the accepted complete text and its message metadata. Components use their own handlers. Without handlers, native text is still retained in session history.
+`response.handler` receives the accepted complete text and its message metadata. Components use their own handlers. Without handlers, native text is still retained in session history, but does not count as delivered speech for `requireChatResponse`.
 
 Complete JavaScript calls can execute while streaming continues. If a stream fails after dispatch, the runtime retains completed effects and reports the interruption; it does not replay the program on another model. `options.midStreamFallback` enables restarts before dispatch and requires a preview consumer capable of handling retractions. Normal preview callback failures are ignored; failed retractions stop generation. A final delivery failure can fail execution.
 
@@ -283,7 +287,7 @@ const getEvidence = new Tool({
 
 Inventories and diagnostic previews keep their own small budgets even if a value carries a larger inspection override. Truncation markers are included in the final measured output. Unicode boundaries, cyclic structures, throwing formatters, and accessor properties are handled without changing retained data.
 
-Standalone text is displayed directly. Strings nested in objects or arrays use JSON quoting so source indentation, line endings, and literal escapes remain distinct from the preview's formatting.
+Both `return inspect(value)` and forced ThinkSignal inspection use the native inspector. Standalone text is displayed directly, preserving whitespace, code, and literal tags within its preview budget. Report sections add no XML entity escaping or CDATA. Strings nested in objects or arrays use JSON quoting so source indentation, line endings, and literal escapes remain distinct from the preview's formatting.
 
 `onInspect` customizes previews by purpose and identity. Return `undefined` for the default formatter. The hook receives an isolated read-only snapshot; custom text is still bounded. A formatter failure falls back to default inspection.
 

package/ERRORS.md

@@ -58,6 +58,7 @@ A **critical** failure stops the execution without another model call. Critical
 | `INVALID_COMPONENT_INPUT` | `ComponentInputError`       | Recoverable. `componentName`, `issues`, `expectedInput`. No message was sent.                                                                                                                                     |
 | `INVALID_NATIVE_CALL`     | `NativeProtocolError`       | Recoverable. Malformed native call, invalid JavaScript envelope, or multiple calls in one response. The rejected batch did not execute.                                                                           |
 | `HOST_OPERATION_FAILED`   | `HostOperationError`        | Recoverable. Unawaited tool or operation after JavaScript completion. Started work is joined; feedback distinguishes its effects.                                                                                 |
+| `MISSING_CHAT_RESPONSE`   | `MissingChatResponseError`  | Recoverable. Chat tried to complete through `listen` while the assistant was not the last participant to speak; disabled by `options.requireChatResponse: false`.                                                 |
 | `DELIVERY_FAILED`         | `DeliveryError`             | Recoverable. Text/component handler failed. Earlier acknowledged sends remain delivered; later queued sends are skipped. Inspect `cause`.                                                                         |
 | `HOOK_FAILED`             | `HookError`                 | Recoverable. A hook rejected an operation; original `cause` is retained.                                                                                                                                          |
 | `INVALID_MEMORY_VALUE`    | `MemoryValueError`          | Recoverable. Unsupported/cyclic memory or inspection value. Failed captures also appear in `iteration.errors` and the memory report.                                                                              |
@@ -89,10 +90,12 @@ Validation errors include a path/message list and the expected argument shape as
 
 [`src/runtime/error-recovery.test.ts`](./src/runtime/error-recovery.test.ts) runs scripted, mocked LLM responses through the real runtime and both VM drivers. Its `.toMatchInlineSnapshot()` assertions show the tool-result feedback actually present in the next model request, including the expected input types. Memory and iteration-budget footers are excluded from the catalogue snapshot so the failure feedback is easy to review. Critical-error tests in [`src/runtime/errors.test.ts`](./src/runtime/errors.test.ts) assert that no additional provider call or business action occurs.
 
-Recovery feedback uses XML-style sections: `<error>` contains the specific error code and readable message, `<stack_trace>` shows source-mapped guest code with line numbers and carets, and `<recovery>` explains how to continue. Tool calls, sent messages, memory changes, and inspection results each have their own section. Content containing XML characters is enclosed in CDATA so code examples, entity literals, and retrieval tags stay unchanged without closing a section. Validation messages preserve line breaks and the expected TypeScript shape.
+Recovery feedback uses XML-style sections: `<error>` contains the specific error code and readable message, `<stack_trace>` shows source-mapped guest code with line numbers and carets, and `<recovery>` explains how to continue. Tool calls, sent messages, memory changes, and inspection results each have their own section. Section tags are readable separators, not a strict XML document. Content is shown verbatim without entity escaping or CDATA, so code examples, entity literals, and retrieval tags stay unchanged. Validation messages preserve line breaks and the expected TypeScript shape.
 
 Source traces are bounded previews around the failure sites, including failures near the end of long programs. The complete annotated source remains available as `CodeExecutionError.stacktrace`. Node and QuickJS may report different column precision; the inline snapshots cover each. Compiler errors show the invalid source. Host failures outside guest execution retain their original `cause` for consumers; the model is not shown a misleading guest stack or internal host paths.
 
-A `ThinkSignal` report separates its reason, guest interruption site (when available), and context. It tells the model to review that context and continue from retained values and acknowledged effects. It does not resume the suspended JavaScript stack.
+A tool's thrown or returned `ThinkSignal` counts as successful execution, with its `context` returned to JavaScript. Multiple signals are collected while code continues. At settlement, they force inspection before any exit hook can run, even when later code raises a recoverable error. The `<forced_inspection>` section groups each tool's name, original call-site line (when available), reason, and result. It explicitly describes this as equivalent to `inspect()` and tells the model not to repeat those calls. Actual downstream failures remain in `iteration.errors` and the report's error sections; cancellation and critical errors still stop execution.
+
+`think_signal` traces include the responsible tool name, tool-call ID, source line, reason, context, and optional metadata. Results are captured after output hooks and before guest mutations, and displayed through the normal inspection hooks and token budgets.
 
 `toJSON()` and `result.diagnostics()` retain codes, messages, criticality, and nested error diagnostics. They are plain data: JSON does not retain the shared symbol brand or Error prototypes, so class guards intentionally do not accept parsed diagnostic JSON. The VM restores typed errors internally before exposing them on iterations.

package/dist/{component-BpMVZYOa.cjs → component-CMFoCHyu.cjs}

@@ -1,7 +1,7 @@
 const require_utils = require("./utils-CTlsXvdj.cjs");
-const require_errors = require("./errors-IhnTKUp7.cjs");
-const require_schema = require("./schema-DBkjo0b7.cjs");
-const require_typings = require("./typings-C1ihexWE.cjs");
+const require_errors = require("./errors-C6ppQUZX.cjs");
+const require_schema = require("./schema-CXlnbb3n.cjs");
+const require_typings = require("./typings-BA_XxAcY.cjs");
 let _bpinternal_zui = require("@bpinternal/zui");
 //#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseCreate.js
 /** Built-in value references. */

package/dist/{component-C27qu6Zv.js → component-DncqP4fB.js}

@@ -1,7 +1,7 @@
 import { A as keys, B as baseAssignValue, C as getAllKeysIn, D as Stack, E as getSymbols, F as isBuffer, G as isObjectLike, H as isObject, K as Symbol, L as isPrototype, N as nodeUtil, O as getPrototype, P as baseUnary, T as getSymbolsIn, U as isArray, Y as __exportAll, b as Uint8Array, k as keysIn, q as root, w as getAllKeys, x as _getTag_default, z as assignValue } from "./utils-BOFzb8Ok.js";
-import { N as ReservedIdentifierError, d as ComponentInputError, y as InvalidComponentError } from "./errors-H4JJFH3S.js";
-import { n as parseSchemaSync, r as schemaInput } from "./schema-Aer_W7Al.js";
-import { n as schemaToTypeScript } from "./typings-D9_aC8aq.js";
+import { P as ReservedIdentifierError, d as ComponentInputError, y as InvalidComponentError } from "./errors-Crk5P8jo.js";
+import { n as parseSchemaSync, r as schemaInput } from "./schema-GE4ISPCR.js";
+import { n as schemaToTypeScript } from "./typings-BEVDvtuk.js";
 import { z } from "@bpinternal/zui";
 //#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseCreate.js
 /** Built-in value references. */

package/dist/context.d.ts

@@ -93,7 +93,7 @@ export declare namespace IterationStatuses {
             /** The value returned by the executed code (or the context provided by a ThinkSignal). */
             variables: unknown;
             metadata?: Record<string, unknown>;
-            /** A tool paused execution; it did not finish or return normally. */
+            /** A legacy VM control-flow signal paused execution. Tool ThinkSignals now use forced inspection. */
             interrupted?: boolean;
         };
     };

package/dist/{custom-client-BDkgBR2w.js → custom-client-C-WXvLD9.js}

@@ -1,11 +1,11 @@
 import { a as getTokenizer } from "./utils-BOFzb8Ok.js";
-import { C as InvalidMessageError, F as TokenOverflowError, H as isLLMzError, N as ReservedIdentifierError, O as LoopExceededError, P as SessionStateError, T as InvalidSessionError, _ as InternalError, b as InvalidConfigurationError, i as describeError, l as CognitiveError, p as ExecutionAbortedError, t as Signals, u as CompactionError, x as InvalidEventError } from "./errors-H4JJFH3S.js";
-import { i as createComponentRegistry, n as assertValidComponent } from "./component-C27qu6Zv.js";
-import { t as Tool } from "./tool--gK91eez.js";
-import { t as Exit } from "./exit-CPNk3vbz.js";
-import { t as DEFAULT_TOOL_RESULT_MAX_TOKENS } from "./truncate-BSoH2-nY.js";
-import { a as cloneMemoryValue, c as freezeMemoryValue, f as createInspector, i as renderMemory, l as RESERVED_RUNTIME_NAMES, o as decodeMemoryValue, r as Memory, s as encodeMemoryValue } from "./quickjs-variant-DlPi9-Sx.js";
-import { o as resolveResponse, t as getNativeSystemMessage } from "./native-DvTH9vFe.js";
+import { C as InvalidMessageError, F as SessionStateError, I as TokenOverflowError, O as LoopExceededError, P as ReservedIdentifierError, T as InvalidSessionError, U as isLLMzError, _ as InternalError, b as InvalidConfigurationError, i as describeError, l as CognitiveError, p as ExecutionAbortedError, t as Signals, u as CompactionError, x as InvalidEventError } from "./errors-Crk5P8jo.js";
+import { i as createComponentRegistry, n as assertValidComponent } from "./component-DncqP4fB.js";
+import { t as Tool } from "./tool-DstssiAs.js";
+import { t as Exit } from "./exit-DMPwCSba.js";
+import { t as DEFAULT_TOOL_RESULT_MAX_TOKENS } from "./truncate-BEKbdo3t.js";
+import { a as cloneMemoryValue, c as freezeMemoryValue, f as createInspector, i as renderMemory, l as RESERVED_RUNTIME_NAMES, o as decodeMemoryValue, r as Memory, s as encodeMemoryValue } from "./quickjs-variant-CtuGagsb.js";
+import { o as resolveResponse, t as getNativeSystemMessage } from "./native-n_718Z-T.js";
 import { z } from "@bpinternal/zui";
 import { ulid } from "ulid";
 import { Cognitive } from "@botpress/cognitive";
@@ -325,6 +325,14 @@ function normalizeMessage(message) {
 	validateInputMessage(normalized);
 	return normalized;
 }
+/** Only actual participant content counts as speech, including image/audio-only messages. */
+function inputSpeaker(message) {
+	var _message$content;
+	return (Array.isArray(message.content) ? message.content.some((part) => {
+		var _part$text;
+		return part.type !== "text" || Boolean((_part$text = part.text) === null || _part$text === void 0 ? void 0 : _part$text.trim());
+	}) : Boolean((_message$content = message.content) === null || _message$content === void 0 ? void 0 : _message$content.trim())) && (message.role === "user" || message.role === "assistant") ? message.role : null;
+}
 function createAssistantMessage(response) {
 	var _response$toolCalls;
 	if (response.assistantMessage) return asSessionMessage(response.assistantMessage);
@@ -493,6 +501,7 @@ function validateRestoredHistory(state) {
 	if (!Array.isArray(state.groups) || !Array.isArray(state.pendingInputs)) throw new InvalidSessionError("Session history and queued inputs must be arrays.");
 	if (!Number.isSafeInteger(state.turn) || state.turn < 0 || !Number.isSafeInteger(state.iteration) || state.iteration < 0) throw new InvalidSessionError("Session turn and iteration counters must be non-negative safe integers");
 	if (typeof state.activeTurn !== "boolean" || state.activeTurn && (!state.turn || !state.turnId)) throw new InvalidSessionError("Session processing state must identify an active turn.");
+	if (state.lastSpeaker !== void 0 && state.lastSpeaker !== null && !["user", "assistant"].includes(state.lastSpeaker)) throw new InvalidSessionError("Session last speaker must be user, assistant, or null.");
 	const groupIds = /* @__PURE__ */ new Set();
 	const callIds = /* @__PURE__ */ new Set();
 	let previousIteration = 0;
@@ -593,6 +602,7 @@ var Session = class Session {
 	#pendingInputs = [];
 	#activeTurn = false;
 	#locked = false;
+	#lastSpeaker = null;
 	constructor(options = {}) {
 		this.id = `session_${ulid()}`;
 		this.memory = new Memory({
@@ -617,6 +627,15 @@ var Session = class Session {
 	get transcript() {
 		return structuredClone([...this.#allGroups().flatMap((group) => group.source ? [group.source] : group.messages), ...this.#pendingInputs.map((input) => input.source ?? input.message)]);
 	}
+	/** Last participant who spoke in the active history. Events and queued inputs do not count. */
+	get lastSpeaker() {
+		return this.#lastSpeaker;
+	}
+	/** Record acknowledged text or component delivery, never generation alone. */
+	recordAssistantDelivery(iterationId) {
+		this.#getActiveIteration(iterationId);
+		this.#lastSpeaker = "assistant";
+	}
 	get pendingMessages() {
 		return structuredClone(this.#pendingInputs.map((input) => input.message));
 	}
@@ -705,12 +724,15 @@ var Session = class Session {
 		this.#turn++;
 		this.#turnId = `turn_${ulid()}`;
 		this.#activeTurn = true;
-		for (const input of this.#pendingInputs) this.#groups.push({
-			id: input.id,
-			turn: this.#turn,
-			messages: [input.message],
-			...input.source ? { source: input.source } : {}
-		});
+		for (const input of this.#pendingInputs) {
+			if (!input.source) this.#lastSpeaker = inputSpeaker(input.message) ?? this.#lastSpeaker;
+			this.#groups.push({
+				id: input.id,
+				turn: this.#turn,
+				messages: [input.message],
+				...input.source ? { source: input.source } : {}
+			});
+		}
 		this.#pendingInputs = [];
 	}
 	/** Mark the active input batch complete without consuming newly queued input. */
@@ -1033,6 +1055,7 @@ var Session = class Session {
 			groups: this.#groups.map(serializeGroup),
 			memory: this.memory.serialize(),
 			pendingInputs: structuredClone(this.#pendingInputs),
+			lastSpeaker: this.#lastSpeaker,
 			activeTurn: this.#activeTurn,
 			latestResultId: this.#latestResultId,
 			compaction
@@ -1051,6 +1074,7 @@ var Session = class Session {
 		session.#groups = state.groups.map(restoreGroup);
 		session.#pendingInputs = structuredClone(state.pendingInputs);
 		session.#activeTurn = state.activeTurn;
+		session.#lastSpeaker = state.lastSpeaker ?? null;
 		session.#latestResultId = state.latestResultId;
 		Object.defineProperty(session, "memory", {
 			value: Memory.restore(state.memory, () => session.#resultBytes()),

package/dist/{custom-client-MytucGI-.cjs → custom-client-Cgt9_0r1.cjs}

@@ -1,11 +1,11 @@
 const require_utils = require("./utils-CTlsXvdj.cjs");
-const require_errors = require("./errors-IhnTKUp7.cjs");
-const require_component = require("./component-BpMVZYOa.cjs");
-const require_tool = require("./tool-Da_F-N-5.cjs");
-const require_exit = require("./exit-BUgJ5qi5.cjs");
-const require_truncate = require("./truncate-nV3Mxr6-.cjs");
-const require_quickjs_variant = require("./quickjs-variant-DJwYDSsb.cjs");
-const require_native = require("./native-Bm6L9zOb.cjs");
+const require_errors = require("./errors-C6ppQUZX.cjs");
+const require_component = require("./component-CMFoCHyu.cjs");
+const require_tool = require("./tool-_wK9hQOb.cjs");
+const require_exit = require("./exit-BOtKWPuT.cjs");
+const require_truncate = require("./truncate-uomAMGPs.cjs");
+const require_quickjs_variant = require("./quickjs-variant-21IO97PF.cjs");
+const require_native = require("./native-0bq5ATZM.cjs");
 let _bpinternal_zui = require("@bpinternal/zui");
 let ulid = require("ulid");
 let _botpress_cognitive = require("@botpress/cognitive");
@@ -325,6 +325,14 @@ function normalizeMessage(message) {
 	validateInputMessage(normalized);
 	return normalized;
 }
+/** Only actual participant content counts as speech, including image/audio-only messages. */
+function inputSpeaker(message) {
+	var _message$content;
+	return (Array.isArray(message.content) ? message.content.some((part) => {
+		var _part$text;
+		return part.type !== "text" || Boolean((_part$text = part.text) === null || _part$text === void 0 ? void 0 : _part$text.trim());
+	}) : Boolean((_message$content = message.content) === null || _message$content === void 0 ? void 0 : _message$content.trim())) && (message.role === "user" || message.role === "assistant") ? message.role : null;
+}
 function createAssistantMessage(response) {
 	var _response$toolCalls;
 	if (response.assistantMessage) return asSessionMessage(response.assistantMessage);
@@ -493,6 +501,7 @@ function validateRestoredHistory(state) {
 	if (!Array.isArray(state.groups) || !Array.isArray(state.pendingInputs)) throw new require_errors.InvalidSessionError("Session history and queued inputs must be arrays.");
 	if (!Number.isSafeInteger(state.turn) || state.turn < 0 || !Number.isSafeInteger(state.iteration) || state.iteration < 0) throw new require_errors.InvalidSessionError("Session turn and iteration counters must be non-negative safe integers");
 	if (typeof state.activeTurn !== "boolean" || state.activeTurn && (!state.turn || !state.turnId)) throw new require_errors.InvalidSessionError("Session processing state must identify an active turn.");
+	if (state.lastSpeaker !== void 0 && state.lastSpeaker !== null && !["user", "assistant"].includes(state.lastSpeaker)) throw new require_errors.InvalidSessionError("Session last speaker must be user, assistant, or null.");
 	const groupIds = /* @__PURE__ */ new Set();
 	const callIds = /* @__PURE__ */ new Set();
 	let previousIteration = 0;
@@ -593,6 +602,7 @@ var Session = class Session {
 	#pendingInputs = [];
 	#activeTurn = false;
 	#locked = false;
+	#lastSpeaker = null;
 	constructor(options = {}) {
 		this.id = `session_${(0, ulid.ulid)()}`;
 		this.memory = new require_quickjs_variant.Memory({
@@ -617,6 +627,15 @@ var Session = class Session {
 	get transcript() {
 		return structuredClone([...this.#allGroups().flatMap((group) => group.source ? [group.source] : group.messages), ...this.#pendingInputs.map((input) => input.source ?? input.message)]);
 	}
+	/** Last participant who spoke in the active history. Events and queued inputs do not count. */
+	get lastSpeaker() {
+		return this.#lastSpeaker;
+	}
+	/** Record acknowledged text or component delivery, never generation alone. */
+	recordAssistantDelivery(iterationId) {
+		this.#getActiveIteration(iterationId);
+		this.#lastSpeaker = "assistant";
+	}
 	get pendingMessages() {
 		return structuredClone(this.#pendingInputs.map((input) => input.message));
 	}
@@ -705,12 +724,15 @@ var Session = class Session {
 		this.#turn++;
 		this.#turnId = `turn_${(0, ulid.ulid)()}`;
 		this.#activeTurn = true;
-		for (const input of this.#pendingInputs) this.#groups.push({
-			id: input.id,
-			turn: this.#turn,
-			messages: [input.message],
-			...input.source ? { source: input.source } : {}
-		});
+		for (const input of this.#pendingInputs) {
+			if (!input.source) this.#lastSpeaker = inputSpeaker(input.message) ?? this.#lastSpeaker;
+			this.#groups.push({
+				id: input.id,
+				turn: this.#turn,
+				messages: [input.message],
+				...input.source ? { source: input.source } : {}
+			});
+		}
 		this.#pendingInputs = [];
 	}
 	/** Mark the active input batch complete without consuming newly queued input. */
@@ -1033,6 +1055,7 @@ var Session = class Session {
 			groups: this.#groups.map(serializeGroup),
 			memory: this.memory.serialize(),
 			pendingInputs: structuredClone(this.#pendingInputs),
+			lastSpeaker: this.#lastSpeaker,
 			activeTurn: this.#activeTurn,
 			latestResultId: this.#latestResultId,
 			compaction
@@ -1051,6 +1074,7 @@ var Session = class Session {
 		session.#groups = state.groups.map(restoreGroup);
 		session.#pendingInputs = structuredClone(state.pendingInputs);
 		session.#activeTurn = state.activeTurn;
+		session.#lastSpeaker = state.lastSpeaker ?? null;
 		session.#latestResultId = state.latestResultId;
 		Object.defineProperty(session, "memory", {
 			value: require_quickjs_variant.Memory.restore(state.memory, () => session.#resultBytes()),

package/dist/errors/catalog.d.ts

@@ -211,6 +211,12 @@ export declare class HostOperationError extends LLMzError<'HOST_OPERATION_FAILED
     readonly code = "HOST_OPERATION_FAILED";
     constructor(message: string, options?: ErrorOptions);
 }
+/** Chat tried to wait for the user without delivering any message. */
+export declare class MissingChatResponseError extends LLMzError<'MISSING_CHAT_RESPONSE'> {
+    static readonly is: (value: unknown) => value is MissingChatResponseError;
+    readonly code = "MISSING_CHAT_RESPONSE";
+    constructor(message: string, options?: ErrorOptions);
+}
 /** Message delivery failed; external delivery may have partially completed. */
 export declare class DeliveryError extends LLMzError<'DELIVERY_FAILED'> {
     static readonly is: (value: unknown) => value is DeliveryError;
@@ -268,6 +274,7 @@ export declare const errorClasses: {
     NativeProtocolError: typeof NativeProtocolError;
     HostOperationError: typeof HostOperationError;
     DeliveryError: typeof DeliveryError;
+    MissingChatResponseError: typeof MissingChatResponseError;
     HookError: typeof HookError;
     ExecutionAbortedError: typeof ExecutionAbortedError;
     InternalError: typeof InternalError;

package/dist/{errors-IhnTKUp7.cjs → errors-C6ppQUZX.cjs}

@@ -306,6 +306,14 @@ var HostOperationError = class extends LLMzError {
 		super(message, false, options);
 	}
 };
+/** Chat tried to wait for the user without delivering any message. */
+var MissingChatResponseError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "MISSING_CHAT_RESPONSE");
+	code = "MISSING_CHAT_RESPONSE";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
 /** Message delivery failed; external delivery may have partially completed. */
 var DeliveryError = class extends LLMzError {
 	static is = (value) => isLLMzError(value, "DELIVERY_FAILED");
@@ -371,6 +379,7 @@ const errorClasses$1 = {
 	NativeProtocolError,
 	HostOperationError,
 	DeliveryError,
+	MissingChatResponseError,
 	HookError,
 	ExecutionAbortedError,
 	InternalError
@@ -407,6 +416,7 @@ const ERROR_CODES = /* @__PURE__ */ new Set([
 	"INVALID_NATIVE_CALL",
 	"HOST_OPERATION_FAILED",
 	"DELIVERY_FAILED",
+	"MISSING_CHAT_RESPONSE",
 	"HOOK_FAILED",
 	"EXECUTION_ABORTED",
 	"INTERNAL_ERROR"
@@ -595,6 +605,12 @@ var VMLoopSignal = class extends VMSignal {
 		this.message = Signals.serializeError(this);
 	}
 };
+/**
+* A successful tool result that requires model inspection before completion.
+* Tools may throw or return this signal. Its context becomes the JavaScript
+* return value; calls and assignments continue, and inspection overrides any
+* attempted exit at iteration settlement. Cancellation and critical errors still stop execution.
+*/
 var ThinkSignal = class extends VMLoopSignal {
 	reason;
 	context;
@@ -767,6 +783,12 @@ Object.defineProperty(exports, "MemoryValueError", {
 		return MemoryValueError;
 	}
 });
+Object.defineProperty(exports, "MissingChatResponseError", {
+	enumerable: true,
+	get: function() {
+		return MissingChatResponseError;
+	}
+});
 Object.defineProperty(exports, "NativeProtocolError", {
 	enumerable: true,
 	get: function() {

package/dist/{errors-H4JJFH3S.js → errors-Crk5P8jo.js}

@@ -306,6 +306,14 @@ var HostOperationError = class extends LLMzError {
 		super(message, false, options);
 	}
 };
+/** Chat tried to wait for the user without delivering any message. */
+var MissingChatResponseError = class extends LLMzError {
+	static is = (value) => isLLMzError(value, "MISSING_CHAT_RESPONSE");
+	code = "MISSING_CHAT_RESPONSE";
+	constructor(message, options) {
+		super(message, false, options);
+	}
+};
 /** Message delivery failed; external delivery may have partially completed. */
 var DeliveryError = class extends LLMzError {
 	static is = (value) => isLLMzError(value, "DELIVERY_FAILED");
@@ -371,6 +379,7 @@ const errorClasses$1 = {
 	NativeProtocolError,
 	HostOperationError,
 	DeliveryError,
+	MissingChatResponseError,
 	HookError,
 	ExecutionAbortedError,
 	InternalError
@@ -407,6 +416,7 @@ const ERROR_CODES = /* @__PURE__ */ new Set([
 	"INVALID_NATIVE_CALL",
 	"HOST_OPERATION_FAILED",
 	"DELIVERY_FAILED",
+	"MISSING_CHAT_RESPONSE",
 	"HOOK_FAILED",
 	"EXECUTION_ABORTED",
 	"INTERNAL_ERROR"
@@ -595,6 +605,12 @@ var VMLoopSignal = class extends VMSignal {
 		this.message = Signals.serializeError(this);
 	}
 };
+/**
+* A successful tool result that requires model inspection before completion.
+* Tools may throw or return this signal. Its context becomes the JavaScript
+* return value; calls and assignments continue, and inspection overrides any
+* attempted exit at iteration settlement. Cancellation and critical errors still stop execution.
+*/
 var ThinkSignal = class extends VMLoopSignal {
 	reason;
 	context;
@@ -617,4 +633,4 @@ registerErrorClass("VMSignal", VMSignal);
 registerErrorClass("VMLoopSignal", VMLoopSignal);
 registerErrorClass("ThinkSignal", ThinkSignal);
 //#endregion
-export { MemoryValueError as A, UnknownToolError as B, InvalidMessageError as C, LLMzError as D, InvalidToolError as E, TokenOverflowError as F, isLLMzError as H, ToolExecutionError as I, ToolInputError as L, ObjectPropertyError as M, ReservedIdentifierError as N, LoopExceededError as O, SessionStateError as P, UnknownComponentError as R, InvalidExitError as S, InvalidSessionError as T, isCriticalError as V, InternalError as _, cleanStackTrace as a, InvalidConfigurationError as b, CodeFormattingError as c, ComponentInputError as d, DeliveryError as f, HostOperationError as g, HookError as h, describeError as i, NativeProtocolError as j, MemoryCapacityError as k, CognitiveError as l, ExitInputError as m, ThinkSignal as n, AssignmentError as o, ExecutionAbortedError as p, VMSignal as r, CodeExecutionError as s, Signals as t, CompactionError as u, InvalidCodeError as v, InvalidObjectError as w, InvalidEventError as x, InvalidComponentError as y, UnknownExitError as z };
+export { MemoryValueError as A, UnknownExitError as B, InvalidMessageError as C, LLMzError as D, InvalidToolError as E, SessionStateError as F, isCriticalError as H, TokenOverflowError as I, ToolExecutionError as L, NativeProtocolError as M, ObjectPropertyError as N, LoopExceededError as O, ReservedIdentifierError as P, ToolInputError as R, InvalidExitError as S, InvalidSessionError as T, isLLMzError as U, UnknownToolError as V, InternalError as _, cleanStackTrace as a, InvalidConfigurationError as b, CodeFormattingError as c, ComponentInputError as d, DeliveryError as f, HostOperationError as g, HookError as h, describeError as i, MissingChatResponseError as j, MemoryCapacityError as k, CognitiveError as l, ExitInputError as m, ThinkSignal as n, AssignmentError as o, ExecutionAbortedError as p, VMSignal as r, CodeExecutionError as s, Signals as t, CompactionError as u, InvalidCodeError as v, InvalidObjectError as w, InvalidEventError as x, InvalidComponentError as y, UnknownComponentError as z };

package/dist/errors.d.ts

@@ -39,6 +39,12 @@ export declare class VMLoopSignal extends VMSignal {
     static readonly is: (value: unknown) => value is VMLoopSignal;
     constructor(message: string);
 }
+/**
+ * A successful tool result that requires model inspection before completion.
+ * Tools may throw or return this signal. Its context becomes the JavaScript
+ * return value; calls and assignments continue, and inspection overrides any
+ * attempted exit at iteration settlement. Cancellation and critical errors still stop execution.
+ */
 export declare class ThinkSignal extends VMLoopSignal {
     reason: string;
     context?: any;