llmz 0.9.0 → 1.0.1

package/dist/execute-BYI_U5sR.js

@@ -0,0 +1,1943 @@
+import { g as baseIsEqual, o as init, r as getErrorMessage, u as stripInvalidIdentifiers } from "./utils-BOFzb8Ok.js";
+import { A as MemoryValueError, B as UnknownToolError, F as TokenOverflowError, H as isLLMzError, I as ToolExecutionError, M as ObjectPropertyError, O as LoopExceededError, P as SessionStateError, R as UnknownComponentError, V as isCriticalError, a as cleanStackTrace, b as InvalidConfigurationError, f as DeliveryError, g as HostOperationError, h as HookError, j as NativeProtocolError, k as MemoryCapacityError, l as CognitiveError, m as ExitInputError, n as ThinkSignal, o as AssignmentError, p as ExecutionAbortedError, r as VMSignal, s as CodeExecutionError, t as Signals, u as CompactionError, v as InvalidCodeError, z as UnknownExitError } from "./errors-H4JJFH3S.js";
+import { a as isAnyComponent } from "./component-C27qu6Zv.js";
+import { n as parseSchemaSync } from "./schema-Aer_W7Al.js";
+import { t as DEFAULT_TOOL_RESULT_MAX_TOKENS } from "./truncate-BSoH2-nY.js";
+import { a as cloneMemoryValue, f as createInspector, h as resolveInspectionBudget, m as limitInspectionOutput } from "./quickjs-variant-DlPi9-Sx.js";
+import { n as schemaToTypeScript } from "./typings-D9_aC8aq.js";
+import { a as Context, d as prepareAutoCompaction, f as countNativeRequestTokens, i as SuccessExecutionResult, n as ErrorExecutionResult, p as resolveTokenBudget, s as ListenExit, t as _CustomModelClient, u as stableJSON } from "./custom-client-BDkgBR2w.js";
+import { a as validateNativeToolCalls, i as getRunJavaScriptTool, r as WORKER_RESPONSE_INSTRUCTION } from "./native-DvTH9vFe.js";
+import { a as compile, i as VM_TERMINATION, n as VM_ON_ERROR, r as VM_PROGRAM_COMPLETE, runAsyncFunction, t as withMissingMember } from "./vm-8jxt8PTK.js";
+import { z } from "@bpinternal/zui";
+import { ulid } from "ulid";
+import { Cognitive } from "@botpress/cognitive";
+import { Client } from "@botpress/client";
+import ms from "ms";
+//#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isEqual.js
+/**
+* Performs a deep comparison between two values to determine if they are
+* equivalent.
+*
+* **Note:** This method supports comparing arrays, array buffers, booleans,
+* date objects, error objects, maps, numbers, `Object` objects, regexes,
+* sets, strings, symbols, and typed arrays. `Object` objects are compared
+* by their own, not inherited, enumerable properties. Functions and DOM
+* nodes are compared by strict equality, i.e. `===`.
+*
+* @static
+* @memberOf _
+* @since 0.1.0
+* @category Lang
+* @param {*} value The value to compare.
+* @param {*} other The other value to compare.
+* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+* @example
+*
+* var object = { 'a': 1 };
+* var other = { 'a': 1 };
+*
+* _.isEqual(object, other);
+* // => true
+*
+* object === other;
+* // => false
+*/
+function isEqual(value, other) {
+	return baseIsEqual(value, other);
+}
+//#endregion
+//#region src/abort-signal.ts
+/**
+* Creates a new AbortController that aborts when any of the provided signals abort.
+* This is useful for combining multiple abort conditions (e.g., user cancellation, timeout, parent operation abort).
+*
+* @param signals - Array of AbortSignals to listen to. Undefined/null signals are ignored.
+* @returns A new AbortController that will abort if any input signal aborts
+*
+* @example
+* ```typescript
+* const userController = new AbortController()
+* const timeoutController = new AbortController()
+*
+* // Create a joined controller that aborts if either signal aborts
+* const joinedController = createJoinedAbortController([
+*   userController.signal,
+*   timeoutController.signal
+* ])
+*
+* // Use the joined signal in operations
+* await fetch('/api/data', { signal: joinedController.signal })
+* ```
+*/
+function createJoinedAbortController(signals) {
+	const controller = new AbortController();
+	const validSignals = signals.filter((signal) => signal != null);
+	if (validSignals.length === 0) return controller;
+	for (const signal of validSignals) if (signal.aborted) {
+		controller.abort(signal.reason);
+		return controller;
+	}
+	const abortListeners = [];
+	for (const signal of validSignals) {
+		const listener = () => {
+			controller.abort(signal.reason);
+			cleanup();
+		};
+		signal.addEventListener("abort", listener);
+		abortListeners.push(() => signal.removeEventListener("abort", listener));
+	}
+	const cleanup = () => {
+		abortListeners.forEach((removeListener) => removeListener());
+	};
+	controller.signal.addEventListener("abort", cleanup, { once: true });
+	return controller;
+}
+//#endregion
+//#region src/errors/hooks.ts
+/** Hooks may reject an iteration to request a correction; explicit critical errors still stop execution. */
+async function callHook(callback) {
+	try {
+		return await callback();
+	} catch (cause) {
+		if (isLLMzError(cause) || VMSignal.is(cause)) throw cause;
+		throw new HookError(cause instanceof Error ? cause.message : String(cause), { cause });
+	}
+}
+//#endregion
+//#region src/runtime/execution-activity.ts
+const MAX_ENTRIES = 20;
+const PAYLOAD_PREVIEW_TOKENS = 80;
+const ERROR_PREVIEW_TOKENS = 60;
+const NAME_PREVIEW_TOKENS = 16;
+/** Collect recorded operations, excluding ordinary assistant text delivery. */
+function getExecutionActivity(iteration) {
+	return {
+		calls: iteration.traces.filter((trace) => trace.type === "tool_call"),
+		deliveries: iteration.traces.filter((trace) => trace.type === "message_delivery" && !!trace.message_id)
+	};
+}
+function renderToolCalls(activity, includeRecoveryValues = false, inspector = createInspector(), identity = {}) {
+	if (!activity.calls.length) return;
+	const lines = activity.calls.slice(0, MAX_ENTRIES).map((call) => {
+		const name = call.object ? `${call.object}.${call.tool_name}` : call.tool_name;
+		const outcome = getToolOutcome(call);
+		const detailsIdentity = {
+			...identity,
+			tool: call.tool_name,
+			object: call.object
+		};
+		const input = call.input === void 0 ? "" : inspector(call.input, {
+			purpose: "tool-input",
+			maxTokens: PAYLOAD_PREVIEW_TOKENS,
+			compact: true,
+			identity: detailsIdentity
+		});
+		const details = [`- ${inspector(name, {
+			purpose: "name",
+			maxTokens: NAME_PREVIEW_TOKENS,
+			identity: detailsIdentity
+		})}(${input}): ${outcome}`];
+		if (outcome === "interrupted") {
+			const reason = getInterruption(call).reason;
+			details.push(`pending; ${errorPreview(reason, inspector, detailsIdentity)}`);
+		} else if (!call.success) details.push(`error: ${errorPreview(call.error, inspector, detailsIdentity)}`);
+		else if (includeRecoveryValues) details.push(`returned ${inspector(call.output, {
+			purpose: "tool-output",
+			maxTokens: PAYLOAD_PREVIEW_TOKENS,
+			compact: true,
+			identity: detailsIdentity
+		})}`);
+		return details.join("; ");
+	});
+	if (activity.calls.length > lines.length) lines.push(`- ${activity.calls.length - lines.length} additional calls are recorded in the execution traces.`);
+	return `Tools called\n${lines.join("\n")}`;
+}
+function renderMessageDeliveries({ deliveries }, cancelled = false, inspector = createInspector(), identity = {}) {
+	if (!deliveries.length) return;
+	const lines = deliveries.slice(0, MAX_ENTRIES).map((delivery) => {
+		const outcome = delivery.success === true ? "delivered" : "uncertain";
+		const details = [`- ${messagePreview(delivery.value, inspector, identity)}: ${outcome}`];
+		if (delivery.error !== void 0) details.push(`error: ${errorPreview(delivery.error, inspector, identity)}`);
+		return details.join("; ");
+	});
+	if (deliveries.length > lines.length) lines.push(`- ${deliveries.length - lines.length} additional deliveries are recorded in the execution traces.`);
+	if (deliveries.some((delivery) => delivery.success === false)) lines.push("Messages queued after the failed delivery were skipped.");
+	else if (cancelled) lines.push("Messages still queued when execution was cancelled were skipped.");
+	return `Messages sent\n${lines.join("\n")}`;
+}
+function getInterruption(call) {
+	if ("output" in call && ThinkSignal.is(call.output)) return call.output;
+	if (!call.success) {
+		const error = Signals.maybeDeserializeError(call.error);
+		if (ThinkSignal.is(error)) return error;
+	}
+}
+function getToolOutcome(call) {
+	if (getInterruption(call)) return "interrupted";
+	return call.success ? "succeeded" : "failed";
+}
+function messagePreview(value, inspector, identity) {
+	const component = isAnyComponent(value) ? value : void 0;
+	const detailsIdentity = component ? {
+		...identity,
+		component: component.name
+	} : identity;
+	const body = inspector(component ? component.props : value, {
+		purpose: "message",
+		maxTokens: PAYLOAD_PREVIEW_TOKENS,
+		compact: true,
+		identity: detailsIdentity
+	});
+	if (!component) return body;
+	return `${inspector(component.name, {
+		purpose: "name",
+		maxTokens: NAME_PREVIEW_TOKENS,
+		identity: detailsIdentity
+	})} ${body}`;
+}
+function errorPreview(value, inspector, identity) {
+	const error = Signals.maybeDeserializeError(value);
+	return inspector((error instanceof Error ? error.message : String(error ?? "Unknown error")).replace(/\s+/g, " ").trim(), {
+		purpose: "error",
+		maxTokens: ERROR_PREVIEW_TOKENS,
+		compact: true,
+		identity
+	});
+}
+//#endregion
+//#region src/runtime/execution-diagnostics.ts
+/** XML-style boundaries keep diagnostic text separate from recovery instructions. */
+function reportSection(name, content, maxTokens = 2e3, options = {}) {
+	const escape = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+	const heading = options.heading ? `${escape(options.heading)}\n` : "";
+	const body = limitInspectionOutput(content, maxTokens, false, options.preserve ?? "top");
+	return `<${name}>\n${heading}${/[<&]|\]\]>/.test(body) ? `<![CDATA[\n${body.replaceAll("]]>", "]]]]><![CDATA[>")}\n]]>` : body}\n</${name}>`;
+}
+/** Show the specific failure and guest source, never the host's implementation stack. */
+function renderExecutionDiagnostics(error, message, inspector, identity) {
+	const cause = CodeExecutionError.is(error) ? error.cause : error;
+	const candidate = isLLMzError(cause) ? cause : error;
+	const failure = isLLMzError(candidate) ? candidate : void 0;
+	const sections = [reportSection("error", inspector([failure ? `Code: ${failure.code}` : void 0, (failure === null || failure === void 0 ? void 0 : failure.message) ?? message].filter(Boolean).join("\n"), {
+		purpose: "error",
+		maxTokens: 1e3,
+		identity
+	}), 1e3)];
+	if (CodeExecutionError.is(error) && error.stacktrace) sections.push(renderSourceTrace(error.stacktrace, inspector, identity));
+	else if (InvalidCodeError.is(error) && error.source) sections.push(reportSection("invalid_code", inspector(error.source, {
+		purpose: "code",
+		maxTokens: 800,
+		identity
+	}), 800));
+	return sections;
+}
+/** Keep failure sites visible even when they are near the end of a long program. */
+function renderSourceTrace(stack, inspector, identity) {
+	const lines = stack.split("\n");
+	const marked = lines.flatMap((line, index) => /^> \d+ \|/.test(line) ? [index] : []);
+	const selected = /* @__PURE__ */ new Set();
+	for (const index of marked.slice(0, 8)) for (let nearby = Math.max(0, index - 2); nearby <= Math.min(lines.length - 1, index + 3); nearby++) selected.add(nearby);
+	const excerpt = [];
+	let previous = -1;
+	for (const index of [...selected].sort((a, b) => a - b)) {
+		if (index > previous + 1) excerpt.push("... omitted source ...");
+		excerpt.push(lines[index]);
+		previous = index;
+	}
+	if (selected.size && previous < lines.length - 1) excerpt.push("... omitted source ...");
+	return reportSection("stack_trace", inspector(selected.size ? excerpt.join("\n") : stack, {
+		purpose: "code",
+		maxTokens: 1e3,
+		identity
+	}), 1e3);
+}
+//#endregion
+//#region src/runtime/execution-report.ts
+const MAX_REPORTED_CHANGES = 40;
+const MAX_OVERRIDE_SOURCE_LENGTH = 3e3;
+/** Format one settled outcome; execution is responsible for deciding what happened. */
+function renderExecutionReport({ outcome, activity, memory, source, requiresExit = false, iteration, identity = { iteration }, inspector = createInspector(), maxTokens = DEFAULT_TOOL_RESULT_MAX_TOKENS, policies }) {
+	const detail = (value) => inspector(value, {
+		purpose: "error",
+		maxTokens: 1e3,
+		identity
+	});
+	const name = (value) => inspector(value, {
+		purpose: "name",
+		maxTokens: 40,
+		identity
+	});
+	const resultSection = (tag, heading, value) => {
+		const budget = resolveInspectionBudget(value, {
+			tokens: maxTokens,
+			policies
+		});
+		return reportSection(tag, inspector(value, {
+			purpose: "result",
+			maxTokens,
+			policies,
+			identity
+		}), budget.tokens, {
+			heading,
+			preserve: budget.preserve
+		});
+	};
+	const sections = [renderStatus(outcome, memory)];
+	if (outcome.type === "error") {
+		sections.push(...renderExecutionDiagnostics(outcome.error, outcome.message, inspector, identity));
+		sections.push(reportSection("recovery", [
+			outcome.exitName !== void 0 ? `Completion through ${outcome.exitName} failed; no exit was applied.` : "Fix the error before continuing.",
+			"The iteration did not complete successfully. Review the error and recorded outcomes before continuing.",
+			"Use retained variables and acknowledged results. Do not repeat completed actions or messages.",
+			"Check uncertain external outcomes before retrying an operation."
+		].join("\n")));
+	} else if (outcome.type === "interrupted") {
+		sections.push(reportSection("interruption", detail(outcome.message ?? "The response stream failed after JavaScript started.")));
+		if (outcome.stacktrace && /^(?:> | {2})?\d+ \|/m.test(outcome.stacktrace)) sections.push(renderSourceTrace(outcome.stacktrace, inspector, identity));
+		sections.push(reportSection("recovery", outcome.reason === "thinking" ? "Execution paused at the thinking request. Remaining statements did not run. Review the context below and continue from retained variables and acknowledged results; do not repeat completed actions or messages." : "The terminal decision was not applied. Earlier actions may have completed. Inspect the recorded outcomes before continuing; do not repeat acknowledged actions or messages."));
+	} else if (outcome.type === "cancelled") sections.push(reportSection("cancellation", detail(outcome.message)));
+	const override = renderExecutionOverride(source === null || source === void 0 ? void 0 : source.executed, source === null || source === void 0 ? void 0 : source.requested, inspector, identity);
+	if (override) {
+		sections.push(reportSection("execution_override", override));
+		if (outcome.type === "inspect" && requiresExit) sections.push(reportSection("recovery", "No exit was applied. The executed program returned an inspection result; use that result for any required completion. Do not call the originally requested business tools merely to compensate for the hook replacement."));
+	}
+	if (outcome.type === "error" && isReferenceError(outcome.error)) sections.push(reportSection("reference_recovery", "REFERENCE RECOVERY\nCheck the Memory overview and JavaScript API for the missing name. Declare new variables with const or let; assignment alone never creates a variable. If a preceding business call already returned, reuse its acknowledged result rather than repeating the call. Do not invent values or functions for unknown names."));
+	const completed = outcome.type === "inspect" || outcome.type === "exit";
+	const calls = renderToolCalls(activity, !!override || !completed, inspector, identity);
+	const deliveries = renderMessageDeliveries(activity, outcome.type === "cancelled", inspector, identity);
+	if (calls) sections.push(reportSection("tool_calls", calls, 4e3));
+	if (deliveries) sections.push(reportSection("messages", deliveries, 4e3));
+	const changes = [renderChanges("Created", memory.created, name), renderChanges("Updated", memory.updated, name)].filter(Boolean).join("\n");
+	if (changes) sections.push(reportSection("memory_changes", `Memory changes\n${changes}`));
+	if (memory.unavailable.length) {
+		const failures = memory.unavailable.slice(0, MAX_REPORTED_CHANGES);
+		const entries = failures.map((failure) => `- ${name(failure.name)}: ${detail(failure.reason)}`);
+		if (memory.unavailable.length > failures.length) entries.push(`- ${memory.unavailable.length - failures.length} additional values could not be retained.`);
+		sections.push(reportSection("memory_errors", `Memory errors\n${entries.join("\n")}`));
+	}
+	if (outcome.type === "inspect") {
+		const heading = outcome.explicit ? "inspect() result" : "Result";
+		sections.push(outcome.available ? resultSection("result", heading, outcome.value) : reportSection("result", "Unavailable; see memory errors above.", maxTokens, { heading }));
+	} else if (outcome.type === "exit") sections.push(resultSection("completion", `Completion\nExit "${outcome.name}" completed.`, outcome.value === void 0 ? "" : outcome.value));
+	else {
+		sections.push(reportSection("result", "Not produced; execution did not complete an inspection.", maxTokens, { heading: "inspect() result" }));
+		if (outcome.type === "interrupted" && outcome.reason === "thinking" && outcome.context !== void 0) sections.push(resultSection("interruption_context", "Interruption context", outcome.context));
+	}
+	return sections.join("\n\n");
+}
+function renderStatus(outcome, memory) {
+	switch (outcome.type) {
+		case "cancelled": return "run_javascript: cancelled";
+		case "interrupted": return outcome.reason === "thinking" ? "run_javascript: paused" : "run_javascript: interrupted";
+		case "error": return "run_javascript: failed";
+		case "inspect":
+		case "exit": return memory.unavailable.length ? "run_javascript: completed with memory errors\nJavaScript ran successfully, but some values could not be retained." : "run_javascript: succeeded";
+	}
+}
+function isReferenceError(value) {
+	const error = Signals.maybeDeserializeError(value);
+	return UnknownToolError.is(error) || UnknownToolError.is(error === null || error === void 0 ? void 0 : error.cause) || (CodeExecutionError.is(error) ? error.originalErrorName : error === null || error === void 0 ? void 0 : error.name) === "ReferenceError";
+}
+/** Keep the requested assistant call intact while disclosing the source the host actually ran. */
+function renderExecutionOverride(executedCode, requestedCode, inspector = createInspector(), identity) {
+	if (executedCode === void 0 || requestedCode === void 0 || executedCode === requestedCode) return;
+	const source = executedCode.slice(0, MAX_OVERRIDE_SOURCE_LENGTH);
+	return [
+		"EXECUTION OVERRIDE",
+		"The host onBeforeExecution hook replaced the requested JavaScript. The original assistant tool call records the requested program. Replacement source is shown below; the outcomes report what actually executed.",
+		"Continue from the actual results and retained variables. Do not replay the requested program to compensate for this intentional replacement.",
+		"Replacement JavaScript (bounded preview):",
+		inspector(source, {
+			purpose: "code",
+			maxTokens: 800,
+			identity
+		}),
+		...source.length < executedCode.length ? ["The replacement source preview was truncated."] : []
+	].join("\n");
+}
+function renderChanges(label, changes, name) {
+	if (!changes.length) return;
+	const names = changes.slice(0, MAX_REPORTED_CHANGES).map((change) => name(change.name));
+	const lines = [`${label}: ${names.join(", ")}`];
+	if (changes.length > names.length) lines.push(`${changes.length - names.length} more changes are retained in memory.`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/runtime/generate.ts
+const STREAM_IDLE_TIMEOUT = 18e4;
+const STATIC_TOKEN_PARTS = [
+	"instructions",
+	"tools",
+	"protocol"
+];
+const staticTokenEstimates = /* @__PURE__ */ new WeakMap();
+function assertSuccessfulGeneration(metadata) {
+	if (!metadata || metadata.provider === "unknown") throw new CognitiveError("LLM generation failed: missing successful provider metadata");
+	if (metadata.stopReason === "max_tokens") {
+		var _metadata$usage;
+		throw new TokenOverflowError("LLM generation did not complete: stopReason=max_tokens", (_metadata$usage = metadata.usage) === null || _metadata$usage === void 0 ? void 0 : _metadata$usage.outputTokens, void 0, "output");
+	}
+	if (metadata.stopReason === "content_filter" || metadata.stopReason === "other") throw new CognitiveError(`LLM generation did not complete: stopReason=${metadata.stopReason}`);
+}
+function measureNativeContextTokens(iteration, messages, tools, total) {
+	let estimates = staticTokenEstimates.get(iteration);
+	if (!estimates) {
+		var _iteration$tokens;
+		const initial = (_iteration$tokens = iteration.tokens) === null || _iteration$tokens === void 0 ? void 0 : _iteration$tokens.context;
+		estimates = {
+			instructions: (initial === null || initial === void 0 ? void 0 : initial.instructions) ?? 0,
+			tools: (initial === null || initial === void 0 ? void 0 : initial.tools) ?? 0,
+			protocol: (initial === null || initial === void 0 ? void 0 : initial.protocol) ?? 0
+		};
+		staticTokenEstimates.set(iteration, estimates);
+	}
+	const history = messages.filter((message) => message.role !== "system");
+	const emptyRequestTokens = countNativeRequestTokens([], []);
+	const requestWithToolsTokens = countNativeRequestTokens([], tools);
+	const requestWithHistoryTokens = countNativeRequestTokens(history, tools);
+	const structuralTokens = Math.min(total, emptyRequestTokens);
+	const schemaTokens = Math.min(total - structuralTokens, Math.max(0, requestWithToolsTokens - emptyRequestTokens));
+	const iterations = Math.min(total - structuralTokens - schemaTokens, Math.max(0, requestWithHistoryTokens - requestWithToolsTokens));
+	const systemBudget = total - structuralTokens - schemaTokens - iterations;
+	const estimatedSystemParts = STATIC_TOKEN_PARTS.reduce((sum, part) => sum + estimates[part], 0);
+	const scale = estimatedSystemParts > 0 ? Math.min(1, systemBudget / estimatedSystemParts) : 0;
+	const instructions = Math.floor(estimates.instructions * scale);
+	const toolsTokens = Math.floor(estimates.tools * scale) + schemaTokens;
+	const protocol = Math.floor(estimates.protocol * scale);
+	return {
+		total,
+		framework: total - instructions - toolsTokens - protocol - iterations,
+		instructions,
+		tools: toolsTokens,
+		protocol,
+		iterations
+	};
+}
+/** A client may ignore its AbortSignal; cancellation must still release LLMz. */
+function abortable(operation, signal) {
+	return new Promise((resolve, reject) => {
+		const aborted = () => reject(signal.reason ?? /* @__PURE__ */ new Error("Generation aborted"));
+		operation.then(resolve, reject).finally(() => signal.removeEventListener("abort", aborted));
+		if (signal.aborted) {
+			aborted();
+			return;
+		}
+		signal.addEventListener("abort", aborted, { once: true });
+	});
+}
+function validateResponse(output, calls, assistant) {
+	if (typeof output !== "string") throw new CognitiveError("Provider returned invalid assistant output");
+	if (!Array.isArray(calls)) throw new CognitiveError("Provider returned invalid native tool calls");
+	const ids = /* @__PURE__ */ new Set();
+	for (const call of calls) {
+		if (!call || typeof call.id !== "string" || !call.id || ids.has(call.id)) throw new CognitiveError("Provider returned missing or duplicate native call IDs");
+		if (typeof call.name !== "string" || !call.name || !call.input || typeof call.input !== "object" || Array.isArray(call.input)) throw new CognitiveError("Provider returned invalid native tool arguments");
+		ids.add(call.id);
+	}
+	if (assistant) {
+		var _assistant$content;
+		if (assistant.role !== "assistant") throw new CognitiveError("Provider continuation must be an assistant message");
+		const normalized = (assistant.toolCalls ?? []).map((call) => ({
+			id: call.id,
+			name: call.function.name,
+			input: call.function.arguments ?? {}
+		}));
+		if (stableJSON(normalized) !== stableJSON(calls)) throw new CognitiveError("Provider assistant message and normalized tool calls disagree");
+		if ((typeof assistant.content === "string" ? assistant.content : ((_assistant$content = assistant.content) === null || _assistant$content === void 0 ? void 0 : _assistant$content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("")) ?? "") !== output) throw new CognitiveError("Provider assistant message and visible output disagree");
+	}
+}
+async function prepareNativeRequest({ iteration, ctx, cognitive, controller, metadata, onBeforeRequest }) {
+	const modelRefs = Array.isArray(iteration.model) ? iteration.model : [iteration.model];
+	if (!modelRefs.length) throw new CognitiveError("At least one model is required.");
+	const models = await Promise.all(modelRefs.map(async (ref) => {
+		try {
+			return await abortable(cognitive.getModelDetails(ref), controller.signal);
+		} catch (error) {
+			throw new CognitiveError(`Failed to fetch model details for ${ref}: ${getErrorMessage(error)}`, { cause: error });
+		}
+	}));
+	const model = models[0];
+	const { limit, output: reserve } = resolveTokenBudget(models, ctx.maxTokens);
+	const tools = [getRunJavaScriptTool(!!ctx.chat)];
+	const system = [iteration.systemMessage];
+	const budgetInstruction = getBudgetInstruction(ctx, iteration);
+	const budget = `\n\nExecution budget: response ${ctx.iterations.length} of ${ctx.loop}. ${budgetInstruction}`;
+	const buildMessages = (retainedIds, summary) => {
+		const history = ctx.session.requestMessages({
+			inspector: ctx.inspector,
+			retainedIterationIds: retainedIds,
+			summary
+		});
+		const messages = [...structuredClone(system), ...history];
+		const last = messages.at(-1);
+		if (last) last.content = typeof last.content === "string" ? last.content + budget : [...last.content ?? [], {
+			type: "text",
+			text: budget.trim()
+		}];
+		return messages;
+	};
+	const compaction = await prepareAutoCompaction(ctx.session, {
+		client: cognitive,
+		model: iteration.model,
+		signal: controller.signal,
+		contextWindow: ctx.maxTokens,
+		iterationId: iteration.id,
+		inputLimit: limit - reserve,
+		metadata,
+		measure: (ids, summary) => countNativeRequestTokens(buildMessages(ids, summary), tools)
+	});
+	let messages = buildMessages((compaction === null || compaction === void 0 ? void 0 : compaction.retainedIterationIds) ?? ctx.session.retainedIterationIds, compaction === null || compaction === void 0 ? void 0 : compaction.summary);
+	let tokens = countNativeRequestTokens(messages, tools);
+	const override = await callHook(() => onBeforeRequest === null || onBeforeRequest === void 0 ? void 0 : onBeforeRequest({
+		messages: structuredClone(messages),
+		iteration,
+		controller
+	}));
+	if (override) {
+		messages = structuredClone(override.messages);
+		tokens = countNativeRequestTokens(messages, tools);
+	}
+	if (tokens > limit - reserve) throw new TokenOverflowError(override ? "The onBeforeRequest messages exceed the context budget. Shorten them or increase options.maxTokens." : "The native prompt exceeds the context budget. Compact session input or increase options.maxTokens.", tokens, limit - reserve);
+	controller.signal.throwIfAborted();
+	compaction === null || compaction === void 0 || compaction.commit();
+	if (iteration.tokens) {
+		iteration.tokens.limit = limit;
+		iteration.tokens.context = measureNativeContextTokens(iteration, messages, tools, tokens);
+	}
+	const hasAudio = messages.some((message) => Array.isArray(message.content) && message.content.some((part) => part.type === "audio"));
+	return {
+		input: {
+			model: iteration.model,
+			temperature: iteration.temperature,
+			responseFormat: "text",
+			reasoningEffort: iteration.reasoningEffort,
+			messages,
+			tools,
+			toolControl: {
+				mode: ctx.chat ? "auto" : "required",
+				parallel: false
+			},
+			maxTokens: reserve,
+			meta: metadata ? { metadata } : void 0,
+			options: {
+				...hasAudio ? { transcriptionModel: ctx.transcriptionModel ?? "fast" } : {},
+				...ctx.maxTimeToFirstToken ? { maxTimeToFirstToken: ctx.maxTimeToFirstToken } : {},
+				...ctx.midStreamFallback ? { midStreamFallback: true } : {}
+			}
+		},
+		model
+	};
+}
+function getBudgetInstruction(ctx, iteration) {
+	if (ctx.iterations.length < ctx.loop) return `Inspect business results that need interpretation before completing; never guess missing completion fields. Once the required facts are known, complete using retained values without repeating successful calls. ${ctx.chat ? "Component delivery needs no inspection. Keep lookups and retries silent unless progress updates were requested. If requested, include the update alongside the continuing call." : WORKER_RESPONSE_INSTRUCTION}`;
+	if (ctx.chat) return "This is the last response. Answer from inspected evidence with normal assistant text, or use JavaScript with an explicit return exit(\"listen\") or another registered named exit. Do not start work that needs another model response.";
+	if (!iteration.exits.length) return `${WORKER_RESPONSE_INSTRUCTION} This is the last response. Every JavaScript program must explicitly return inspect(value) with the available evidence. Do not start work that needs another model response.`;
+	return `${WORKER_RESPONSE_INSTRUCTION} This is the last response. Finish with return exit("NAME", payload) from run_javascript, using a registered name. Build the payload from inspected $return and retained variables; do not repeat successful lookups to reconstruct it. If the task is incomplete, report it honestly with an incomplete or error payload only when the exit schema permits it. Assistant prose and inspection returns do not complete a worker. Do not start work that requires another model response.`;
+}
+async function consumeNativeStream({ cognitive, input, controller, maxIdleTime, onChunk }) {
+	const streamController = createJoinedAbortController([controller.signal]);
+	const stream = cognitive.generateTextStream(input, { signal: streamController.signal });
+	let completed = false;
+	try {
+		while (true) {
+			controller.signal.throwIfAborted();
+			const chunk = await readNextStreamChunk(stream, streamController, maxIdleTime);
+			if (chunk.done) {
+				completed = true;
+				return;
+			}
+			await onChunk(chunk.value);
+		}
+	} finally {
+		streamController.abort("LLM stream closed");
+		if (!completed) stream.return(void 0).catch(() => {});
+	}
+}
+async function readNextStreamChunk(stream, controller, maxIdleTime) {
+	let timer;
+	const timeout = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => {
+			controller.abort("LLM stream stalled");
+			reject(new CognitiveError("LLM stream stalled"));
+		}, maxIdleTime);
+	});
+	try {
+		return await abortable(Promise.race([stream.next(), timeout]), controller.signal);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+async function generateCode({ iteration, ctx, cognitive, controller, metadata, onSendDelta, onToolCalls, onBeforeRequest }) {
+	var _toolCalls$find;
+	const startedAt = Date.now();
+	controller.signal.throwIfAborted();
+	const { input, model } = await prepareNativeRequest({
+		iteration,
+		ctx,
+		cognitive,
+		controller,
+		metadata,
+		onBeforeRequest
+	});
+	iteration.recordTrace({
+		type: "llm_call_started",
+		started_at: startedAt,
+		model: model.id
+	});
+	let output = "";
+	let toolCalls = [];
+	let responseMetadata;
+	let assistantMessage;
+	let continuation;
+	let attempt = 1;
+	let ttft;
+	let ttl;
+	let previewed = false;
+	let accepted = false;
+	let dispatchedCalls;
+	let dispatchedFingerprint;
+	let offeredFingerprint;
+	const messageMetadata = () => ({
+		iterationId: iteration.id,
+		id: `${iteration.id}:${attempt}:text`
+	});
+	const preview = async (delta) => {
+		try {
+			await (onSendDelta === null || onSendDelta === void 0 ? void 0 : onSendDelta(delta));
+		} catch (err) {
+			if (delta.restart) throw new CognitiveError(`LLM stream restart handler failed: ${getErrorMessage(err)}`, { cause: err });
+		}
+	};
+	try {
+		controller.signal.throwIfAborted();
+		if (typeof cognitive.generateTextStream === "function") {
+			let finished = false;
+			await consumeNativeStream({
+				cognitive,
+				input,
+				controller,
+				maxIdleTime: Math.max(STREAM_IDLE_TIMEOUT, ctx.maxTimeToFirstToken ?? 0),
+				onChunk: async (value) => {
+					if (value.error) throw new CognitiveError(`LLM generation failed: ${value.error}`);
+					if (value.restart) {
+						if (dispatchedCalls) throw new CognitiveError("The LLM stream restarted after tool execution began; completed work cannot be replayed.");
+						if (!ctx.midStreamFallback) throw new CognitiveError("Unexpected LLM stream restart");
+						if (!Number.isInteger(value.restart.attempt) || value.restart.attempt <= attempt) throw new CognitiveError("Provider returned an invalid stream restart attempt");
+						if (value.output || value.toolCalls || value.finished) throw new CognitiveError("A stream restart must not contain output from either attempt");
+						iteration.recordTrace({
+							type: "llm_call_restarted",
+							started_at: Date.now(),
+							...value.restart
+						});
+						previewed = false;
+						await preview({
+							restart: true,
+							iterationId: iteration.id,
+							...value.restart
+						});
+						attempt = value.restart.attempt;
+						output = "";
+						toolCalls = [];
+						responseMetadata = void 0;
+						assistantMessage = void 0;
+						continuation = void 0;
+						ttft = void 0;
+						ttl = void 0;
+						finished = false;
+						previewed = false;
+						offeredFingerprint = void 0;
+						return;
+					}
+					const callsFingerprint = value.toolCalls ? stableJSON(value.toolCalls) : void 0;
+					if (dispatchedCalls && callsFingerprint !== void 0 && callsFingerprint !== dispatchedFingerprint) throw new CognitiveError("The LLM stream changed tool calls after execution began; completed work cannot be replayed.");
+					const repeatedDispatchedCalls = dispatchedCalls && callsFingerprint === dispatchedFingerprint;
+					if (finished && (value.output || value.toolCalls && !repeatedDispatchedCalls || value.assistantMessage || value.continuation !== void 0)) throw new CognitiveError("Received content after stream completion");
+					if (value.metadata) responseMetadata = value.metadata;
+					if (value.toolCalls) {
+						toolCalls = dispatchedCalls ?? value.toolCalls;
+						if (onToolCalls && !dispatchedCalls && toolCalls.length && offeredFingerprint !== callsFingerprint) {
+							validateResponse(output + (value.output ?? ""), toolCalls, value.assistantMessage ?? assistantMessage);
+							if (responseMetadata) assertSuccessfulGeneration(responseMetadata);
+							const snapshot = freezeToolCalls(structuredClone(toolCalls));
+							offeredFingerprint = callsFingerprint;
+							if (onToolCalls(snapshot)) {
+								dispatchedCalls = snapshot;
+								dispatchedFingerprint = callsFingerprint;
+								toolCalls = snapshot;
+							}
+						}
+					}
+					if (value.assistantMessage) assistantMessage = value.assistantMessage;
+					if (value.continuation !== void 0) continuation = value.continuation;
+					if (value.output) {
+						output += value.output;
+						ttl = Date.now() - startedAt;
+						ttft ??= ttl;
+						previewed = true;
+						await preview({
+							restart: false,
+							...messageMetadata(),
+							type: "text",
+							delta: value.output,
+							content: output
+						});
+					}
+					if (value.finished) finished = true;
+				}
+			});
+			if (!finished) throw new CognitiveError("LLM stream ended without a completion signal");
+		} else {
+			const response = await abortable(cognitive.generateText(input, { signal: controller.signal }), controller.signal);
+			if (response.error) throw new CognitiveError(`LLM generation failed: ${response.error}`);
+			output = response.output ?? "";
+			toolCalls = response.toolCalls ?? [];
+			assistantMessage = response.assistantMessage;
+			continuation = response.continuation;
+			responseMetadata = response.metadata;
+		}
+		controller.signal.throwIfAborted();
+		assertSuccessfulGeneration(responseMetadata);
+		validateResponse(output, toolCalls, assistantMessage);
+		if ((responseMetadata === null || responseMetadata === void 0 ? void 0 : responseMetadata.stopReason) === "tool_calls" && !toolCalls.length) throw new CognitiveError("Provider signaled tool calls but returned none");
+		accepted = true;
+	} catch (err) {
+		throw isLLMzError(err) ? err : new CognitiveError(`LLM generation failed: ${getErrorMessage(err)}`, { cause: err });
+	} finally {
+		const usage = (responseMetadata === null || responseMetadata === void 0 ? void 0 : responseMetadata.usage) ?? {
+			inputTokens: 0,
+			outputTokens: 0,
+			inputCost: 0,
+			outputCost: 0
+		};
+		iteration.llm = {
+			started_at: startedAt,
+			ended_at: Date.now(),
+			status: accepted ? "success" : "error",
+			output,
+			cached: (responseMetadata === null || responseMetadata === void 0 ? void 0 : responseMetadata.cached) ?? false,
+			tokens: usage.inputTokens + usage.outputTokens,
+			spend: (responseMetadata === null || responseMetadata === void 0 ? void 0 : responseMetadata.cost) ?? 0,
+			model: (responseMetadata === null || responseMetadata === void 0 ? void 0 : responseMetadata.model) ?? model.id,
+			time_to_first_token: ttft,
+			time_to_last_token: ttl,
+			usage
+		};
+		if (iteration.tokens) Object.assign(iteration.tokens, {
+			input: usage.inputTokens,
+			output: usage.outputTokens,
+			total: usage.inputTokens + usage.outputTokens
+		});
+		if (!accepted && previewed) await preview({
+			restart: true,
+			iterationId: iteration.id,
+			attempt: attempt + 1,
+			fromModel: model.id,
+			toModel: model.id,
+			reason: "Generation did not complete successfully"
+		});
+	}
+	const code = (_toolCalls$find = toolCalls.find((call) => call.name === "run_javascript")) === null || _toolCalls$find === void 0 || (_toolCalls$find = _toolCalls$find.input) === null || _toolCalls$find === void 0 ? void 0 : _toolCalls$find.code;
+	iteration.recordTrace({
+		type: "llm_call_success",
+		started_at: startedAt,
+		ended_at: Date.now(),
+		model: model.id,
+		code: typeof code === "string" ? code : ""
+	});
+	return {
+		attempt,
+		output,
+		toolCalls,
+		assistantMessage,
+		continuation,
+		metadata: responseMetadata,
+		messageMetadata: messageMetadata()
+	};
+}
+/** Keep execution's accepted arguments independent of later provider or callback mutations. */
+function freezeToolCalls(calls) {
+	const freeze = (value) => {
+		if (!value || typeof value !== "object" || Object.isFrozen(value)) return;
+		for (const child of Object.values(value)) freeze(child);
+		Object.freeze(value);
+	};
+	freeze(calls);
+	return calls;
+}
+//#endregion
+//#region src/runtime/inspection-values.ts
+/** Explicit display policies apply only to unchanged values in this JavaScript execution. */
+var InspectionValues = class {
+	_primitives = /* @__PURE__ */ new Map();
+	_objects = /* @__PURE__ */ new Map();
+	capture(value, policy) {
+		this._register(value, policy, true);
+	}
+	captureDefault(value, maxTokens) {
+		this._register(value, {
+			maxTokens,
+			preserve: "top"
+		}, false);
+	}
+	_register(value, policy, explicit) {
+		let captured;
+		try {
+			captured = cloneMemoryValue(value);
+		} catch {
+			return;
+		}
+		if (!captured || typeof captured !== "object") {
+			const previous = this._primitives.get(captured);
+			this._primitives.set(captured, this._mergePolicy(previous, {
+				policy,
+				explicit
+			}));
+			return;
+		}
+		const key = this._objectKey(captured);
+		const candidates = this._objects.get(key) ?? [];
+		const previous = candidates.find((candidate) => isEqual(candidate.value, captured));
+		if (previous) {
+			const selected = this._mergePolicy(previous, {
+				policy,
+				explicit
+			});
+			previous.policy = selected.policy;
+			previous.explicit = selected.explicit;
+			return;
+		}
+		candidates.push({
+			value: captured,
+			policy: { ...policy },
+			explicit
+		});
+		this._objects.set(key, candidates);
+	}
+	/** Match unchanged VM copies without rebuilding a wrapped display graph. */
+	getPolicy = (value) => {
+		var _candidates$find;
+		if (!value || typeof value !== "object") {
+			var _this$_primitives$get;
+			return (_this$_primitives$get = this._primitives.get(value)) === null || _this$_primitives$get === void 0 ? void 0 : _this$_primitives$get.policy;
+		}
+		return (_candidates$find = (this._objects.get(this._objectKey(value)) ?? []).find((candidate) => isEqual(candidate.value, value))) === null || _candidates$find === void 0 ? void 0 : _candidates$find.policy;
+	};
+	_objectKey(value) {
+		return Array.isArray(value) ? `array:${value.length}` : `object:${Object.keys(value).length}`;
+	}
+	_mergePolicy(previous, next) {
+		if ((previous === null || previous === void 0 ? void 0 : previous.explicit) && !next.explicit) return previous;
+		if (!previous || !previous.explicit && next.explicit || next.policy.maxTokens < previous.policy.maxTokens) return {
+			policy: { ...next.policy },
+			explicit: next.explicit
+		};
+		if (next.policy.maxTokens === previous.policy.maxTokens && next.policy.preserve !== previous.policy.preserve) return {
+			policy: {
+				maxTokens: next.policy.maxTokens,
+				preserve: "top"
+			},
+			explicit: next.explicit
+		};
+		return previous;
+	}
+};
+//#endregion
+//#region src/runtime/javascript-api.ts
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/**
+* Component methods send synchronously; the runtime joins delivery in close().
+* Inspection returns a decision, while exit latches an outcome and stops the program.
+*/
+function createJavaScriptApi({ iteration, components, exits, deliver, signal, onError }) {
+	const decisions = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Set();
+	let open = true;
+	let outstanding = [];
+	let delivery;
+	let nextMessage = 0;
+	let terminalOutcome;
+	let interruption;
+	let criticalFailure;
+	const termination = /* @__PURE__ */ new Error("JavaScript execution terminated.");
+	const reportError = (error) => {
+		onError === null || onError === void 0 || onError(error);
+		if (isCriticalError(error)) {
+			criticalFailure = error;
+			complete();
+		}
+	};
+	const throwIfTerminated = () => {
+		if (criticalFailure) throw criticalFailure;
+		if (interruption || terminalOutcome) throw termination;
+	};
+	const assertOpen = () => {
+		throwIfTerminated();
+		if (!open) throw new HostOperationError("JavaScript has completed. Host operations and Object writes are closed.");
+		signal === null || signal === void 0 || signal.throwIfAborted();
+	};
+	const resolve = (value) => {
+		if (!isRecord(value) || typeof value.__llmz_decision !== "string") return;
+		return decisions.get(value.__llmz_decision);
+	};
+	const issue = (outcome) => {
+		assertOpen();
+		const token = ulid();
+		decisions.set(token, outcome);
+		return Object.freeze({ __llmz_decision: token });
+	};
+	const validateExit = (name = "listen", value) => {
+		assertOpen();
+		const registered = exits.find((candidate) => candidate.name === name || candidate.aliases.includes(name));
+		if (!registered) throw new UnknownExitError(name, exits.map((exit) => exit.name));
+		if (!registered.schema && value !== void 0) throw new ExitInputError(registered.name, [{
+			path: [],
+			message: "This exit takes no payload."
+		}], "undefined");
+		const schema = registered.zSchema;
+		const parsed = schema ? parseSchemaSync(schema, value, `Exit "${registered.name}"`) : void 0;
+		if (parsed && !parsed.success) throw new ExitInputError(registered.name, parsed.error.issues, schemaToTypeScript(schema));
+		const validated = parsed === null || parsed === void 0 ? void 0 : parsed.data;
+		return {
+			type: "exit",
+			exit: registered,
+			value: cloneMemoryValue(validated)
+		};
+	};
+	const exit = (name = "listen", value) => {
+		let outcome;
+		try {
+			outcome = validateExit(name, value);
+		} catch (error) {
+			reportError(error);
+			throw error;
+		}
+		terminalOutcome = outcome;
+		complete();
+		throw termination;
+	};
+	const track = (operation) => {
+		assertOpen();
+		const tracked = (async () => operation())().then((value) => {
+			pending.delete(tracked);
+			return value;
+		}, (error) => {
+			pending.delete(tracked);
+			if (isCriticalError(error)) {
+				criticalFailure = error;
+				complete();
+			}
+			if (!interruption && ThinkSignal.is(error)) {
+				interruption = error;
+				complete();
+			}
+			throw error;
+		});
+		pending.add(tracked);
+		tracked.catch(() => {});
+		return tracked;
+	};
+	const enqueue = (messages) => {
+		const dispatch = async () => deliver(messages);
+		delivery = delivery ? delivery.then(dispatch) : dispatch();
+		delivery.catch(() => {});
+		return delivery;
+	};
+	const complete = () => {
+		if (!open) return;
+		open = false;
+		outstanding = [...pending];
+	};
+	const close = async () => {
+		var _delivered$;
+		complete();
+		const [, delivered] = await Promise.all([Promise.allSettled(outstanding), Promise.allSettled(delivery ? [delivery] : [])]);
+		if (criticalFailure) throw criticalFailure;
+		if (((_delivered$ = delivered[0]) === null || _delivered$ === void 0 ? void 0 : _delivered$.status) === "rejected") throw delivered[0].reason;
+		if (outstanding.length && !interruption) throw new HostOperationError(`JavaScript completed with ${outstanding.length} unawaited host operation(s). Await all business tools before returning. Started operations have settled and may have completed effects; do not replay them.`);
+	};
+	const inspect = (value) => issue({
+		type: "inspect",
+		value: cloneMemoryValue(value)
+	});
+	const chat = withMissingMember(Object.fromEntries([...components].map(([name, component]) => [name, Object.freeze((input) => {
+		assertOpen();
+		let rendered;
+		try {
+			rendered = component.render(input);
+		} catch (error) {
+			reportError(error);
+			throw error;
+		}
+		enqueue([{
+			id: `${iteration.nativeCallId ?? iteration.id}:message:${++nextMessage}`,
+			component: rendered
+		}]);
+	})])), (name) => {
+		const error = new UnknownComponentError(name, [...components.keys()]);
+		onError === null || onError === void 0 || onError(error);
+		throw error;
+	});
+	return {
+		bindings: Object.freeze({
+			exit: Object.freeze(exit),
+			inspect: Object.freeze(inspect),
+			chat: Object.freeze(chat)
+		}),
+		resolve,
+		isReceipt: (value) => resolve(value) !== void 0,
+		getTerminalOutcome: () => terminalOutcome,
+		getInterruption: () => interruption,
+		throwIfTerminated,
+		track,
+		assertOpen,
+		reportError,
+		complete,
+		close
+	};
+}
+//#endregion
+//#region src/runtime/utils.ts
+const finalizeIteration = async ({ iteration, status, controller, onIterationEnd }) => {
+	if (status) iteration.end(status);
+	if (iteration.status.type === "pending") return;
+	try {
+		await (onIterationEnd === null || onIterationEnd === void 0 ? void 0 : onIterationEnd(iteration, controller));
+	} catch (err) {
+		if (isCriticalError(err)) {
+			iteration.recordError(err);
+			throw err;
+		}
+		iteration.recordError(new HookError(err instanceof Error ? err.message : String(err), { cause: err }));
+		console.error(err);
+	}
+};
+//#endregion
+//#region src/runtime/tool-wrapper.ts
+const SLOW_TOOL_WARNING = ms("15s");
+function wrapTool({ tool, object, iteration, beforeHook, afterHook, onTruncation, onResult, controller }) {
+	return async function(input) {
+		controller.signal.throwIfAborted();
+		const toolCallId = `tcall_${ulid()}`;
+		const originalInput = input;
+		let reportedInput = originalInput;
+		let effectiveInput = input;
+		const alertSlowTool = setTimeout(() => iteration.recordTrace({
+			type: "tool_slow",
+			tool_name: tool.name,
+			tool_call_id: toolCallId,
+			started_at: Date.now(),
+			input: reportedInput,
+			object,
+			duration: SLOW_TOOL_WARNING
+		}), SLOW_TOOL_WARNING);
+		const toolStart = Date.now();
+		let output;
+		let error;
+		let success = true;
+		let signalToThrow;
+		const pushToolCallTrace = () => {
+			iteration.recordTrace({
+				type: "tool_call",
+				tool_call_id: toolCallId,
+				native_call_id: iteration.nativeCallId,
+				started_at: toolStart,
+				ended_at: Date.now(),
+				tool_name: tool.name,
+				object,
+				input: reportedInput,
+				output,
+				error,
+				success
+			});
+		};
+		const handleSignals = async (err) => {
+			if (output === err) return true;
+			if (ThinkSignal.is(err)) {
+				signalToThrow = err;
+				iteration.recordTrace({
+					type: "think_signal",
+					started_at: Date.now(),
+					line: 0,
+					ended_at: Date.now()
+				});
+				success = true;
+				output = err;
+				const afterRes = await callHook(() => afterHook === null || afterHook === void 0 ? void 0 : afterHook({
+					iteration,
+					tool,
+					input: originalInput,
+					output,
+					controller,
+					object,
+					toolCallId,
+					nativeCallId: iteration.nativeCallId
+				}));
+				if (typeof (afterRes === null || afterRes === void 0 ? void 0 : afterRes.output) !== "undefined") output = afterRes.output;
+				return true;
+			}
+			return false;
+		};
+		try {
+			const beforeRes = await callHook(() => beforeHook === null || beforeHook === void 0 ? void 0 : beforeHook({
+				iteration,
+				tool,
+				input: effectiveInput,
+				controller,
+				object,
+				toolCallId,
+				nativeCallId: iteration.nativeCallId
+			}));
+			if (typeof (beforeRes === null || beforeRes === void 0 ? void 0 : beforeRes.input) !== "undefined") effectiveInput = beforeRes.input;
+			controller.signal.throwIfAborted();
+			output = await tool.execute(effectiveInput, {
+				callId: toolCallId,
+				iterationId: iteration.id,
+				nativeCallId: iteration.nativeCallId,
+				onTruncation,
+				onInput: (parsed) => {
+					controller.signal.throwIfAborted();
+					if (effectiveInput === originalInput) reportedInput = parsed;
+				}
+			});
+			const afterRes = await callHook(() => afterHook === null || afterHook === void 0 ? void 0 : afterHook({
+				iteration,
+				tool,
+				input: effectiveInput,
+				output,
+				controller,
+				object,
+				toolCallId,
+				nativeCallId: iteration.nativeCallId
+			}));
+			if (typeof (afterRes === null || afterRes === void 0 ? void 0 : afterRes.output) !== "undefined") output = afterRes.output;
+		} catch (err) {
+			if (!await handleSignals(err)) {
+				success = false;
+				error = isLLMzError(err) ? err : new ToolExecutionError(tool.name, err);
+				iteration.recordError(error);
+			}
+		} finally {
+			clearTimeout(alertSlowTool);
+			pushToolCallTrace();
+		}
+		if (!success) throw error;
+		if (signalToThrow) throw signalToThrow;
+		onResult === null || onResult === void 0 || onResult(output);
+		return output;
+	};
+}
+//#endregion
+//#region src/runtime/vm-context.ts
+const buildVMContext = ({ ctx, iteration, controller, onBeforeTool, onAfterTool, onTruncation, onToolResult, javascriptApi }) => {
+	const memoryBindings = ctx.session.getBindings();
+	const vmContext = {
+		...stripInvalidIdentifiers(memoryBindings),
+		[VM_ON_ERROR]: (error) => {
+			iteration.recordError(error);
+		}
+	};
+	const reject = (error) => {
+		iteration.recordError(error);
+		javascriptApi === null || javascriptApi === void 0 || javascriptApi.reportError(error);
+		throw error;
+	};
+	for (const name of ["$return", "$iterations"]) Object.defineProperty(vmContext, name, {
+		value: memoryBindings[name],
+		enumerable: true,
+		writable: false,
+		configurable: false
+	});
+	if (javascriptApi) {
+		for (const [name, value] of Object.entries(javascriptApi.bindings)) Object.defineProperty(vmContext, name, {
+			value,
+			enumerable: true,
+			writable: false,
+			configurable: false
+		});
+		Object.defineProperty(vmContext, VM_PROGRAM_COMPLETE, { value: javascriptApi.complete });
+		Object.defineProperty(vmContext, VM_TERMINATION, { value: {
+			isTerminated: () => javascriptApi.getTerminalOutcome() !== void 0 || javascriptApi.getInterruption() !== void 0,
+			check: javascriptApi.throwIfTerminated,
+			getSignal: javascriptApi.getInterruption
+		} });
+	}
+	for (const obj of iteration.objects) {
+		const internalValues = {};
+		const instance = {};
+		for (const { name, writable, type } of obj.properties ?? []) {
+			const initialValue = ctx.session.memory.getObjectPropertyValue(obj.name, name);
+			internalValues[name] = freezePropertyValue(initialValue);
+			const schema = type ?? z.any();
+			Object.defineProperty(instance, name, {
+				enumerable: true,
+				configurable: true,
+				get() {
+					return internalValues[name];
+				},
+				set(value) {
+					javascriptApi === null || javascriptApi === void 0 || javascriptApi.assertOpen();
+					if (!writable) reject(new AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`));
+					let parsed;
+					try {
+						parsed = parseSchemaSync(schema, value, `Object property ${obj.name}.${name}`);
+					} catch (error) {
+						const failure = iteration.recordError(error);
+						javascriptApi === null || javascriptApi === void 0 || javascriptApi.reportError(failure);
+						throw failure;
+					}
+					if (!parsed.success) reject(new ObjectPropertyError(obj.name, name, parsed.error.issues, schemaToTypeScript(schema)));
+					internalValues[name] = freezePropertyValue(cloneMemoryValue(parsed.data));
+					iteration.recordTrace({
+						type: "property",
+						started_at: Date.now(),
+						object: obj.name,
+						property: name,
+						value: parsed.data
+					});
+					iteration.trackMutation({
+						object: obj.name,
+						property: name,
+						before: initialValue,
+						after: parsed.data
+					});
+				}
+			});
+		}
+		for (const tool of obj.tools ?? []) {
+			const wrapped = wrapTool({
+				tool,
+				object: obj.name,
+				iteration,
+				beforeHook: onBeforeTool,
+				afterHook: onAfterTool,
+				onTruncation,
+				onResult: onToolResult,
+				controller
+			});
+			instance[tool.name] = javascriptApi ? (input) => javascriptApi.track(() => wrapped(input)) : wrapped;
+		}
+		vmContext[obj.name] = withMissingMember(instance, (name) => {
+			const error = new UnknownToolError(`${obj.name}.${name}`, (obj.tools ?? []).map((tool) => `${obj.name}.${tool.name}`));
+			iteration.recordError(error);
+			throw error;
+		});
+	}
+	for (const tool of iteration.tools) {
+		const wrapped = wrapTool({
+			tool,
+			iteration,
+			beforeHook: onBeforeTool,
+			afterHook: onAfterTool,
+			onTruncation,
+			onResult: onToolResult,
+			controller
+		});
+		const callable = javascriptApi ? (input) => javascriptApi.track(() => wrapped(input)) : wrapped;
+		for (const key of [tool.name, ...tool.aliases ?? []]) vmContext[key] = callable;
+	}
+	return vmContext;
+};
+/** Nested edits must go through whole-property assignment so its schema always runs. */
+function freezePropertyValue(value) {
+	if (value && typeof value === "object") {
+		for (const child of Object.values(value)) freezePropertyValue(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+//#endregion
+//#region src/runtime/execute.ts
+/** Each iteration joins generation and execution before settling its transcript. */
+async function executeContext(props) {
+	await init();
+	const result = await executeContextInternal(props);
+	try {
+		var _result$context$chat, _result$context$chat$;
+		await ((_result$context$chat = result.context.chat) === null || _result$context$chat === void 0 || (_result$context$chat$ = _result$context$chat.onExecutionDone) === null || _result$context$chat$ === void 0 ? void 0 : _result$context$chat$.call(_result$context$chat, result));
+	} catch {}
+	return result;
+}
+async function executeContextInternal(props) {
+	var _props$options, _props$options2, _props$options3, _props$options4, _props$options5, _props$options6, _props$options7;
+	const controller = createJoinedAbortController([props.signal]);
+	const ctx = new Context({
+		...props,
+		loop: (_props$options = props.options) === null || _props$options === void 0 ? void 0 : _props$options.loop,
+		timeout: (_props$options2 = props.options) === null || _props$options2 === void 0 ? void 0 : _props$options2.timeout,
+		maxTokens: (_props$options3 = props.options) === null || _props$options3 === void 0 ? void 0 : _props$options3.maxTokens,
+		toolResultMaxTokens: (_props$options4 = props.options) === null || _props$options4 === void 0 ? void 0 : _props$options4.toolResultMaxTokens,
+		maxTimeToFirstToken: (_props$options5 = props.options) === null || _props$options5 === void 0 ? void 0 : _props$options5.maxTimeToFirstToken,
+		midStreamFallback: (_props$options6 = props.options) === null || _props$options6 === void 0 ? void 0 : _props$options6.midStreamFallback,
+		transcriptionModel: (_props$options7 = props.options) === null || _props$options7 === void 0 ? void 0 : _props$options7.transcriptionModel
+	});
+	let release;
+	try {
+		var _ctx$iterations$at;
+		if ("snapshot" in props) throw new InvalidConfigurationError("Snapshots and external pause/resume are no longer supported. Use a session for conversation history and memory.");
+		if ("messages" in props) throw new InvalidConfigurationError("Append input with session.append(message) before calling execute(). execute.messages is no longer supported.");
+		release = ctx.session.acquire();
+		prepareSession(ctx);
+		const client = props.client ?? new Client();
+		const execution = {
+			ctx,
+			props,
+			cognitive: Cognitive.isCognitiveClient(client) || _CustomModelClient.isCustomClient(client) ? client : new Cognitive({ client }),
+			controller
+		};
+		while (ctx.iterations.length < ctx.loop) {
+			const result = await executeNextIteration(execution);
+			if (result) {
+				if (result.isSuccess()) ctx.session.completeTurn();
+				return result;
+			}
+		}
+		const error = new LoopExceededError(ctx.loop);
+		(_ctx$iterations$at = ctx.iterations.at(-1)) === null || _ctx$iterations$at === void 0 || _ctx$iterations$at.recordError(error);
+		return new ErrorExecutionResult(ctx, error);
+	} catch (error) {
+		return new ErrorExecutionResult(ctx, error);
+	} finally {
+		release === null || release === void 0 || release();
+	}
+}
+function prepareSession(ctx) {
+	if (ctx.chat && ctx.session.turn > 0 && !ctx.session.hasActiveTurn && !ctx.session.pendingMessages.length) throw new SessionStateError("No pending input. Append a message to the session before starting another chat turn.");
+	ctx.session.beginTurn();
+}
+async function executeNextIteration(execution) {
+	const { ctx, props, controller } = execution;
+	let onTrace = props.onTrace;
+	const iterationNumber = ctx.iterations.length + 1;
+	const iteration = await ctx.nextIteration((trace) => {
+		onTrace === null || onTrace === void 0 || onTrace({
+			trace,
+			iteration: iterationNumber,
+			controller
+		});
+	});
+	const state = {
+		...execution,
+		iteration,
+		inspectionValues: new InspectionValues()
+	};
+	try {
+		await executeIteration(state);
+	} catch (error) {
+		handleIterationFailure(state, error);
+	} finally {
+		try {
+			try {
+				var _state$capture;
+				state.memory ??= commitMemory(state, (_state$capture = state.capture) === null || _state$capture === void 0 ? void 0 : _state$capture.result);
+			} catch (error) {
+				failFinalization(state, error);
+			}
+			const memory = state.memory;
+			for (const failure of memory.unavailable) iteration.recordError(new MemoryValueError(`Memory variable "${failure.name}": ${failure.reason}`));
+			const outcome = getExecutionOutcome(state, memory);
+			if (state.capture) {
+				var _iteration$sessionInf;
+				ctx.session.appendToolResult(iteration.id, state.capture.call.id, renderExecutionReport({
+					outcome,
+					memory,
+					activity: getExecutionActivity(iteration),
+					source: {
+						requested: state.capture.call.code,
+						executed: iteration.code
+					},
+					requiresExit: !iteration.isChatEnabled,
+					identity: {
+						sessionId: ctx.session.id,
+						...iteration.sessionInfo,
+						iterationId: iteration.id,
+						iteration: (_iteration$sessionInf = iteration.sessionInfo) === null || _iteration$sessionInf === void 0 ? void 0 : _iteration$sessionInf.number
+					},
+					inspector: ctx.inspector,
+					maxTokens: ctx.toolResultMaxTokens,
+					policies: state.inspectionValues.getPolicy
+				}));
+			}
+			try {
+				ctx.session.settleIteration(iteration.id, {
+					outcome: iteration.status.type,
+					error: iteration.error ?? void 0
+				});
+			} catch (error) {
+				if (!MemoryCapacityError.is(error)) throw error;
+				failFinalization(state, error);
+				ctx.session.settleIteration(iteration.id, { outcome: "error" });
+			}
+			await finalizeIteration({
+				iteration,
+				controller,
+				onIterationEnd: props.onIterationEnd
+			});
+		} finally {
+			onTrace = void 0;
+		}
+	}
+	return getIterationResult(state);
+}
+async function executeIteration(state) {
+	const { ctx, props, iteration, cognitive, controller } = state;
+	await callHook(() => {
+		var _props$onIterationSta;
+		return (_props$onIterationSta = props.onIterationStart) === null || _props$onIterationSta === void 0 ? void 0 : _props$onIterationSta.call(props, iteration, controller, ctx);
+	});
+	controller.signal.throwIfAborted();
+	let execution;
+	let assistantCommitted = false;
+	try {
+		var _iteration$response;
+		const generated = await generateCode({
+			iteration,
+			ctx,
+			cognitive,
+			controller,
+			metadata: props.metadata,
+			onSendDelta: (_iteration$response = iteration.response) === null || _iteration$response === void 0 ? void 0 : _iteration$response.onDelta,
+			onBeforeRequest: props.onBeforeRequest,
+			onToolCalls: (calls) => {
+				var _iteration$response2;
+				if (ctx.chat && !((_iteration$response2 = iteration.response) === null || _iteration$response2 === void 0 ? void 0 : _iteration$response2.onDelta)) return false;
+				const validation = validateNativeToolCalls(calls);
+				const call = validation.valid ? validation.call : void 0;
+				if (!call) return false;
+				if (ctx.session.messages.some((message) => {
+					var _message$toolCalls;
+					return (_message$toolCalls = message.toolCalls) === null || _message$toolCalls === void 0 ? void 0 : _message$toolCalls.some((previous) => previous.id === call.id);
+				})) throw new CognitiveError("Native call IDs must be unique in retained session history.");
+				execution = startJavaScriptCall(state, call);
+				return true;
+			}
+		});
+		await (execution === null || execution === void 0 ? void 0 : execution.result);
+		controller.signal.throwIfAborted();
+		const validation = validateNativeToolCalls(generated.toolCalls);
+		ctx.session.appendAssistant(iteration.id, generated);
+		assistantCommitted = true;
+		if (!validation.valid) {
+			await rejectNativeBatch(state, generated, validation.errors);
+			return;
+		}
+		await deliverAssistantText(state, generated);
+		const call = validation.call;
+		if (call) {
+			execution ??= startJavaScriptCall(state, call);
+			await settleJavaScriptCall(state, execution);
+		}
+		if (iteration.status.type === "pending") await finishNativeResponse(state, generated);
+	} catch (error) {
+		if (execution) await preserveInterruptedExecution(state, execution, error, assistantCommitted);
+		throw error;
+	}
+}
+async function rejectNativeBatch({ ctx, iteration }, generated, errors) {
+	var _iteration$response3;
+	const message = [reportSection("error", `Native tool batch rejected before execution:\n${ctx.inspector(errors.join("\n"), {
+		purpose: "error",
+		maxTokens: 500
+	})}`, 500), reportSection("recovery", "No code ran and no actions were performed. Call run_javascript with exactly one non-empty code string.")].join("\n\n");
+	for (const call of generated.toolCalls) ctx.session.appendToolResult(iteration.id, call.id, message);
+	if (generated.output && ((_iteration$response3 = iteration.response) === null || _iteration$response3 === void 0 ? void 0 : _iteration$response3.onDelta)) try {
+		await iteration.response.onDelta({
+			restart: true,
+			iterationId: iteration.id,
+			attempt: generated.attempt + 1,
+			fromModel: generated.metadata.model ?? "unknown",
+			toModel: generated.metadata.model ?? "unknown",
+			reason: message
+		});
+	} catch (error) {
+		throw new CognitiveError(`Could not retract the rejected response: ${getErrorMessage(error)}`);
+	}
+	iteration.end({
+		type: "invalid_code_error",
+		invalid_code_error: { message }
+	}, generated.toolCalls.some((call) => call.name !== "run_javascript") ? new UnknownToolError(generated.toolCalls.find((call) => call.name !== "run_javascript").name, ["run_javascript"], message) : new NativeProtocolError(message));
+}
+async function deliverAssistantText(state, generated) {
+	const { ctx, iteration } = state;
+	if (!generated.output.trim() || !ctx.chat) return;
+	const startedAt = Date.now();
+	const message = {
+		type: "text",
+		text: generated.output
+	};
+	try {
+		var _iteration$response4, _iteration$response4$;
+		await ((_iteration$response4 = iteration.response) === null || _iteration$response4 === void 0 || (_iteration$response4$ = _iteration$response4.handler) === null || _iteration$response4$ === void 0 ? void 0 : _iteration$response4$.call(_iteration$response4, generated.output.trim(), generated.messageMetadata));
+	} catch (cause) {
+		if (isCriticalError(cause)) throw cause;
+		throw new DeliveryError(`Assistant response delivery failed: ${getErrorMessage(cause)}`, { cause });
+	}
+	iteration.recordTrace({
+		type: "message_delivery",
+		value: message,
+		started_at: startedAt,
+		ended_at: Date.now()
+	});
+}
+function startJavaScriptCall(state, call) {
+	const { iteration, controller } = state;
+	iteration.code = call.code;
+	iteration.nativeCallId = call.id;
+	const api = createJavaScriptApi({
+		iteration,
+		components: iteration.components,
+		exits: iteration.exits,
+		signal: controller.signal,
+		deliver: (messages) => deliverJavaScriptMessages(state, messages),
+		onError: (error) => iteration.recordError(error)
+	});
+	return {
+		call,
+		api,
+		result: executeJavaScript(state, api)
+	};
+}
+async function settleJavaScriptCall(state, execution) {
+	const { iteration, controller } = state;
+	const { call, api } = execution;
+	const result = await execution.result;
+	const outcome = result.success && !result.signal ? api.getTerminalOutcome() ?? api.resolve(result.return_value) : void 0;
+	removeCapturedDecisions(result, api);
+	state.capture = {
+		call,
+		result,
+		inspected: (outcome === null || outcome === void 0 ? void 0 : outcome.type) === "inspect"
+	};
+	if ((outcome === null || outcome === void 0 ? void 0 : outcome.type) === "inspect" && result.success) result.return_value = outcome.value;
+	if ((outcome === null || outcome === void 0 ? void 0 : outcome.type) === "exit") {
+		await completeJavaScriptExit(state, result, outcome);
+		return;
+	}
+	if (result.success && containsDecision(result.return_value, api)) {
+		result.captureErrors ??= [];
+		result.captureErrors.push({
+			name: "$return",
+			reason: "Execution decisions cannot be nested inside returned data. Use return inspect(value) with plain values."
+		});
+	}
+	endJavaScriptIteration(iteration, controller, result);
+}
+async function preserveInterruptedExecution(state, execution, error, assistantCommitted) {
+	const { ctx, iteration, controller } = state;
+	execution.api.complete();
+	const result = await execution.result;
+	if (state.memory) return;
+	if (!assistantCommitted) ctx.session.appendAssistant(iteration.id, {
+		output: "",
+		toolCalls: [{
+			id: execution.call.id,
+			name: "run_javascript",
+			input: { code: execution.call.code }
+		}]
+	});
+	removeCapturedDecisions(result, execution.api);
+	if (iteration.status.type === "pending") endFailedIteration(iteration, controller, error);
+	const interrupted = {
+		...result,
+		success: false,
+		signal: void 0,
+		error: error instanceof Error ? error : new Error(getErrorMessage(error)),
+		traces: []
+	};
+	state.capture = {
+		call: execution.call,
+		result: interrupted,
+		inspected: false,
+		interrupted: true
+	};
+}
+function removeCapturedDecisions(result, api) {
+	for (const [name, value] of Object.entries(result.variables)) if (containsDecision(value, api)) {
+		delete result.variables[name];
+		result.captureErrors ??= [];
+		result.captureErrors.push({
+			name,
+			reason: "Execution decisions cannot be retained as memory variables."
+		});
+	}
+}
+function containsDecision(value, api, seen = /* @__PURE__ */ new Set()) {
+	if (api.isReceipt(value)) return true;
+	if (value === null || typeof value !== "object" || seen.has(value)) return false;
+	seen.add(value);
+	return Object.values(value).some((nested) => containsDecision(nested, api, seen));
+}
+async function completeJavaScriptExit(state, result, outcome) {
+	const { iteration, controller, props } = state;
+	state.memory = commitMemory(state, result, false);
+	try {
+		controller.signal.throwIfAborted();
+		await applyNativeExit(iteration, outcome.exit, outcome.value, controller, props.onExit);
+	} catch (error) {
+		endFailedIteration(iteration, controller, error);
+	}
+}
+async function deliverJavaScriptMessages({ ctx, iteration, controller }, messages) {
+	if (!messages.length) return;
+	if (!ctx.chat) throw new DeliveryError("Component delivery requires chat mode.");
+	for (const message of messages) {
+		controller.signal.throwIfAborted();
+		const startedAt = Date.now();
+		try {
+			if (!isAnyComponent(message.component)) throw new DeliveryError("Only registered rich components can be delivered from JavaScript.");
+			const component = iteration.components.get(message.component.name);
+			if (!(component === null || component === void 0 ? void 0 : component.handler)) throw new DeliveryError(`Component "${message.component.name}" has no registered handler.`);
+			await component.handler(message.component.props, {
+				iterationId: iteration.id,
+				id: message.id
+			});
+		} catch (error) {
+			iteration.recordTrace({
+				type: "message_delivery",
+				value: message.component,
+				message_id: message.id,
+				native_call_id: iteration.nativeCallId,
+				success: false,
+				error: getErrorMessage(error),
+				started_at: startedAt,
+				ended_at: Date.now()
+			});
+			throw isCriticalError(error) ? error : new DeliveryError(`Delivery ${message.id} failed: ${getErrorMessage(error)}. Its external outcome is uncertain. Later messages were skipped; earlier acknowledged messages remain delivered.`, { cause: error });
+		}
+		iteration.recordTrace({
+			type: "message_delivery",
+			value: message.component,
+			message_id: message.id,
+			native_call_id: iteration.nativeCallId,
+			success: true,
+			started_at: startedAt,
+			ended_at: Date.now()
+		});
+	}
+}
+async function finishNativeResponse(state, generated) {
+	const { ctx, iteration, controller, props } = state;
+	if (!generated.toolCalls.length && generated.output.trim() && ctx.chat) {
+		await applyNativeExit(iteration, ListenExit, {}, controller, props.onExit);
+		if (!iteration.hasExited()) ctx.session.appendContext(ctx.inspector(iteration.error ?? "Completion rejected.", {
+			purpose: "error",
+			maxTokens: 200
+		}));
+		return;
+	}
+	let reason = iteration.exits.length ? "This is a worker task. Every run_javascript program must explicitly return inspect(value) or return exit(name, payload) with a registered name and a valid payload. Assistant prose alone does not complete the task." : "Every run_javascript program must explicitly return inspect(value). To see a business tool result in the next response, return inspect(result).";
+	if (ctx.chat) reason = generated.toolCalls.length ? "Every run_javascript program must explicitly return inspect(value) or return exit(name, payload). Use return exit(\"listen\") to wait for the user." : "Reply with assistant text, or use run_javascript with an explicit return inspect(value) or return exit(name, payload). Use return exit(\"listen\") to wait for the user.";
+	if (!ctx.chat) reason = `${WORKER_RESPONSE_INSTRUCTION} ${reason}`;
+	iteration.end({
+		type: "thinking_requested",
+		thinking_requested: {
+			reason,
+			variables: {}
+		}
+	});
+	if (!generated.toolCalls.length) ctx.session.appendContext(reason);
+}
+function commitMemory(state, result, includeReturn = true) {
+	const { ctx, iteration, controller } = state;
+	const report = ctx.session.commitIteration({
+		...iteration.sessionInfo,
+		timestamp: Date.now(),
+		variables: result === null || result === void 0 ? void 0 : result.variables,
+		variableWrites: result === null || result === void 0 ? void 0 : result.variableWrites,
+		captureErrors: result === null || result === void 0 ? void 0 : result.captureErrors,
+		hasResult: includeReturn && !!(result === null || result === void 0 ? void 0 : result.success) && !result.signal && !controller.signal.aborted,
+		result: (result === null || result === void 0 ? void 0 : result.success) ? result.return_value : void 0
+	});
+	state.memory = report;
+	for (const mutation of iteration.mutations) {
+		const trace = [...iteration.traces].reverse().find((trace) => trace.type === "property" && trace.object === mutation.object && trace.property === mutation.property);
+		const changes = ctx.session.memory.recordObjectMutations([mutation], {
+			...iteration.sessionInfo,
+			timestamp: (trace === null || trace === void 0 ? void 0 : trace.started_at) ?? Date.now()
+		});
+		report.updated.push(...changes);
+	}
+	return report;
+}
+function failFinalization(state, error) {
+	const { iteration } = state;
+	iteration.status = {
+		type: "execution_error",
+		execution_error: {
+			message: getErrorMessage(error),
+			stack: executionErrorStack(error)
+		}
+	};
+	iteration.ended_ts = Date.now();
+	iteration.exception = iteration.recordError(error);
+	state.terminalError = error;
+	state.memory ??= {
+		created: [],
+		updated: [],
+		unavailable: [],
+		resultAvailable: false
+	};
+}
+function getExecutionOutcome(state, memory) {
+	const { iteration, capture } = state;
+	const status = iteration.status;
+	if (status.type === "aborted") return {
+		type: "cancelled",
+		message: status.aborted.reason
+	};
+	if (capture === null || capture === void 0 ? void 0 : capture.interrupted) return {
+		type: "interrupted",
+		reason: "stream",
+		message: iteration.error ?? void 0
+	};
+	if (status.type === "exit_success") return {
+		type: "exit",
+		name: status.exit_success.exit_name,
+		value: status.exit_success.return_value
+	};
+	if (status.type === "exit_error") return {
+		type: "error",
+		exitName: status.exit_error.exit,
+		message: status.exit_error.message,
+		error: iteration.exception
+	};
+	if (status.type === "thinking_requested") {
+		const thinking = status.thinking_requested;
+		if (thinking.interrupted) {
+			var _capture$result$signa;
+			return {
+				type: "interrupted",
+				reason: "thinking",
+				message: thinking.reason,
+				context: thinking.variables,
+				stacktrace: capture === null || capture === void 0 || (_capture$result$signa = capture.result.signal) === null || _capture$result$signa === void 0 ? void 0 : _capture$result$signa.stack
+			};
+		}
+		return {
+			type: "inspect",
+			value: (capture === null || capture === void 0 ? void 0 : capture.result.success) ? capture.result.return_value : void 0,
+			available: memory.resultAvailable,
+			explicit: (capture === null || capture === void 0 ? void 0 : capture.inspected) ?? false
+		};
+	}
+	return {
+		type: "error",
+		message: iteration.error ?? "Execution failed.",
+		error: iteration.exception ?? (capture === null || capture === void 0 ? void 0 : capture.result.error)
+	};
+}
+function handleIterationFailure(state, error) {
+	const { ctx, iteration, controller } = state;
+	if (iteration.status.type === "pending") endFailedIteration(iteration, controller, error);
+	if (MemoryCapacityError.is(error)) state.memory ??= {
+		created: [],
+		updated: [],
+		unavailable: [],
+		resultAvailable: false
+	};
+	const pending = ctx.session.pendingCalls.filter((call) => call.iterationId === iteration.id);
+	for (const call of pending) {
+		var _state$capture2;
+		if (call.callId === ((_state$capture2 = state.capture) === null || _state$capture2 === void 0 ? void 0 : _state$capture2.call.id)) continue;
+		const outcome = call.callId === iteration.nativeCallId ? "This call failed without a confirmed successful result; its external effects may be incomplete." : "This call was skipped and did not run.";
+		ctx.session.appendToolResult(iteration.id, call.callId, `Execution stopped: ${ctx.inspector(getErrorMessage(error), {
+			purpose: "error",
+			maxTokens: 200
+		})}. ${outcome} Earlier acknowledged calls remain completed.`);
+	}
+	if (isCriticalError(error) || controller.signal.aborted) {
+		state.terminalError = controller.signal.aborted ? new ExecutionAbortedError(getErrorMessage(controller.signal.reason ?? error), { cause: controller.signal.reason ?? error }) : error;
+		return;
+	}
+	if (ctx.session.pendingCalls.length) return;
+	ctx.session.appendContext(`Execution stopped: ${ctx.inspector(getErrorMessage(error), {
+		purpose: "error",
+		maxTokens: 200
+	})}. Continue using the retained state.`);
+}
+function endFailedIteration(iteration, controller, error) {
+	if (controller.signal.aborted) {
+		iteration.end({
+			type: "aborted",
+			aborted: { reason: getErrorMessage(controller.signal.reason ?? error) }
+		}, new ExecutionAbortedError(getErrorMessage(controller.signal.reason ?? error), { cause: controller.signal.reason ?? error }));
+		return;
+	}
+	if (CognitiveError.is(error) || TokenOverflowError.is(error) || CompactionError.is(error)) {
+		iteration.end({
+			type: "generation_error",
+			generation_error: { message: error.message }
+		}, error);
+		return;
+	}
+	if (ThinkSignal.is(error)) {
+		iteration.end({
+			type: "thinking_requested",
+			thinking_requested: {
+				reason: error.reason,
+				variables: error.context,
+				interrupted: true
+			}
+		});
+		return;
+	}
+	iteration.end({
+		type: "execution_error",
+		execution_error: {
+			message: getErrorMessage(error),
+			stack: executionErrorStack(error)
+		}
+	}, error);
+}
+function executionErrorStack(error) {
+	if (CodeExecutionError.is(error) && error.stacktrace) return error.stacktrace;
+	if (HookError.is(error) && error.cause instanceof Error) return cleanStackTrace(error.cause.stack ?? "");
+	if (error instanceof Error) return cleanStackTrace(error.stack ?? "");
+	return "";
+}
+function getIterationResult(state) {
+	const { ctx, iteration } = state;
+	const critical = iteration.errors.find(isCriticalError);
+	state.terminalError ??= critical;
+	if (state.terminalError !== void 0) return new ErrorExecutionResult(ctx, state.terminalError);
+	if (iteration.status.type === "exit_success") {
+		const outcome = iteration.status.exit_success;
+		return new SuccessExecutionResult(ctx, {
+			exit: iteration.exits.find((exit) => exit.name === outcome.exit_name),
+			result: outcome.return_value
+		});
+	}
+	if (iteration.status.type === "aborted") return new ErrorExecutionResult(ctx, iteration.error);
+}
+async function applyNativeExit(iteration, exit, value, controller, onExit) {
+	try {
+		await callHook(() => onExit === null || onExit === void 0 ? void 0 : onExit({
+			exit,
+			result: value
+		}, controller));
+		controller.signal.throwIfAborted();
+		iteration.end({
+			type: "exit_success",
+			exit_success: {
+				exit_name: exit.name,
+				return_value: value
+			}
+		});
+	} catch (error) {
+		if (controller.signal.aborted) throw error;
+		iteration.end({
+			type: "exit_error",
+			exit_error: {
+				exit: exit.name,
+				message: getErrorMessage(error),
+				return_value: value
+			}
+		}, error);
+	}
+}
+async function executeJavaScript(state, api) {
+	const { iteration, ctx, controller, props } = state;
+	const startedAt = Date.now();
+	let result;
+	try {
+		const override = await callHook(() => {
+			var _props$onBeforeExecut;
+			return (_props$onBeforeExecut = props.onBeforeExecution) === null || _props$onBeforeExecut === void 0 ? void 0 : _props$onBeforeExecut.call(props, iteration, controller);
+		});
+		if (typeof (override === null || override === void 0 ? void 0 : override.code) === "string") iteration.code = override.code;
+		controller.signal.throwIfAborted();
+		const code = iteration.code;
+		ctx.session.memory.assertNamesAvailable(compile(code).variables);
+		const vmContext = buildVMContext({
+			ctx,
+			iteration,
+			controller,
+			onBeforeTool: props.onBeforeTool,
+			onAfterTool: props.onAfterTool,
+			onTruncation: (value, policy) => state.inspectionValues.capture(value, policy),
+			onToolResult: (value) => state.inspectionValues.captureDefault(value, ctx.toolResultMaxTokens),
+			javascriptApi: api
+		});
+		result = await runAsyncFunction(vmContext, code, iteration.traces, controller.signal, ctx.timeout, Object.keys(ctx.session.memory.variables), iteration.recordTrace);
+	} catch (error) {
+		result = interruptedVMResult(error);
+	}
+	try {
+		await api.close();
+	} catch (error) {
+		result = {
+			...result,
+			success: !!result.signal,
+			error: error instanceof Error ? error : new Error(getErrorMessage(error)),
+			traces: []
+		};
+	}
+	const interruption = api.getInterruption();
+	if (interruption && !result.signal) {
+		interruption.variables = result.variables;
+		result = {
+			...result,
+			success: true,
+			signal: interruption,
+			error: void 0,
+			return_value: void 0
+		};
+	}
+	iteration.recordTrace({
+		type: "code_execution",
+		lines_executed: result.lines_executed,
+		started_at: startedAt,
+		ended_at: Date.now()
+	});
+	return result;
+}
+function interruptedVMResult(error) {
+	if (ThinkSignal.is(error)) return {
+		success: true,
+		signal: error,
+		return_value: void 0,
+		variables: {},
+		lines_executed: []
+	};
+	return {
+		success: false,
+		error: error instanceof Error ? error : new Error(getErrorMessage(error)),
+		variables: {},
+		lines_executed: [],
+		traces: []
+	};
+}
+function endJavaScriptIteration(iteration, controller, result) {
+	if (controller.signal.aborted) {
+		endFailedIteration(iteration, controller, controller.signal.reason);
+		return;
+	}
+	if (!result.success) {
+		if (InvalidCodeError.is(result.error)) iteration.end({
+			type: "invalid_code_error",
+			invalid_code_error: { message: result.error.message }
+		}, result.error);
+		else endFailedIteration(iteration, controller, result.error);
+		return;
+	}
+	if (ThinkSignal.is(result.signal)) {
+		iteration.end({
+			type: "thinking_requested",
+			thinking_requested: {
+				reason: result.signal.reason,
+				variables: result.signal.context,
+				metadata: result.signal.metadata,
+				interrupted: true
+			}
+		});
+		return;
+	}
+	iteration.end({
+		type: "thinking_requested",
+		thinking_requested: {
+			reason: "JavaScript completed. Inspect the return value and memory changes.",
+			variables: {}
+		}
+	});
+}
+//#endregion
+export { executeContext };