llmz 0.9.0 → 1.0.2

package/dist/execute-DTTfacsi.cjs

@@ -0,0 +1,2062 @@
+const require_utils = require("./utils-CTlsXvdj.cjs");
+const require_errors = require("./errors-C6ppQUZX.cjs");
+const require_component = require("./component-CMFoCHyu.cjs");
+const require_schema = require("./schema-CXlnbb3n.cjs");
+const require_truncate = require("./truncate-uomAMGPs.cjs");
+const require_quickjs_variant = require("./quickjs-variant-21IO97PF.cjs");
+const require_typings = require("./typings-BA_XxAcY.cjs");
+const require_custom_client = require("./custom-client-Cgt9_0r1.cjs");
+const require_native = require("./native-0bq5ATZM.cjs");
+const require_vm = require("./vm-gmekHc0i.cjs");
+let _bpinternal_zui = require("@bpinternal/zui");
+let ulid = require("ulid");
+let _botpress_cognitive = require("@botpress/cognitive");
+let _botpress_client = require("@botpress/client");
+let ms = require("ms");
+ms = require_utils.__toESM(ms, 1);
+//#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 require_utils.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 (require_errors.isLLMzError(cause) || require_errors.VMSignal.is(cause)) throw cause;
+		throw new require_errors.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 = require_quickjs_variant.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 = require_quickjs_variant.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 && require_errors.ThinkSignal.is(call.output)) return call.output;
+	if (!call.success) {
+		const error = require_errors.Signals.maybeDeserializeError(call.error);
+		if (require_errors.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 = require_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 = require_errors.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 = {}) {
+	return `<${name}>\n${options.heading ? `${options.heading}\n` : ""}${require_quickjs_variant.limitInspectionOutput(content, maxTokens, false, options.preserve ?? "top")}\n</${name}>`;
+}
+/** Show the specific failure and guest source, never the host's implementation stack. */
+function renderExecutionDiagnostics(error, message, inspector, identity) {
+	const cause = require_errors.CodeExecutionError.is(error) ? error.cause : error;
+	const candidate = require_errors.isLLMzError(cause) ? cause : error;
+	const failure = require_errors.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 (require_errors.CodeExecutionError.is(error) && error.stacktrace) sections.push(renderSourceTrace(error.stacktrace, inspector, identity));
+	else if (require_errors.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/forced-inspection.ts
+/** Keep attribution and content together, using the same display budgets as inspect(). */
+function renderForcedInspection(inspections, inspector, identity, maxTokens, policies) {
+	return [
+		"<forced_inspection>",
+		"Forced inspection: the tools listed below completed successfully and requested review of their results.",
+		"This is the equivalent of an inspect() call. Do not repeat these tool calls; use the results below and retained variables.",
+		"No exit was applied. Review the evidence before continuing or completing the task.",
+		"",
+		"Tools requesting inspection (lines refer to the executed JavaScript):",
+		...inspections.map((entry) => {
+			const entryIdentity = {
+				...identity,
+				tool: entry.tool
+			};
+			const name = inspector(entry.tool, {
+				purpose: "name",
+				maxTokens: 80,
+				identity: entryIdentity
+			});
+			const reason = inspector(entry.reason, {
+				purpose: "error",
+				maxTokens: 1e3,
+				identity: entryIdentity
+			});
+			const budget = require_quickjs_variant.resolveInspectionBudget(entry.value, {
+				tokens: maxTokens,
+				policies
+			});
+			const result = inspector(entry.value, {
+				purpose: "result",
+				maxTokens,
+				policies,
+				identity: entryIdentity
+			});
+			return [
+				`<tool name="${name}" line="${entry.line ?? "unknown"}">`,
+				`<reason>${reason}</reason>`,
+				reportSection("result", result, budget.tokens, { preserve: budget.preserve }),
+				"</tool>"
+			].join("\n");
+		}),
+		"</forced_inspection>"
+	].join("\n");
+}
+//#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 = require_quickjs_variant.createInspector(), maxTokens = require_truncate.DEFAULT_TOOL_RESULT_MAX_TOKENS, policies }) {
+	var _outcome$forcedInspec, _outcome$forcedInspec2;
+	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 = require_quickjs_variant.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 === "inspect" && ((_outcome$forcedInspec = outcome.forcedInspections) === null || _outcome$forcedInspec === void 0 ? void 0 : _outcome$forcedInspec.length)) {
+		sections.push(renderForcedInspection(outcome.forcedInspections, inspector, identity, maxTokens, policies));
+		if (outcome.downstreamError) {
+			sections.push(...renderExecutionDiagnostics(outcome.downstreamError, require_utils.getErrorMessage(outcome.downstreamError), inspector, identity));
+			sections.push(reportSection("recovery", "A later operation failed. The tool results above were successfully retrieved; inspect them and repair only the failed work. Do not repeat successful calls."));
+		}
+	}
+	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" && ((_outcome$forcedInspec2 = outcome.forcedInspections) === null || _outcome$forcedInspec2 === void 0 ? void 0 : _outcome$forcedInspec2.length) && (!outcome.explicit || outcome.forcedInspections.some((entry) => isEqual(entry.value, outcome.value)))) {} else 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 = require_errors.Signals.maybeDeserializeError(value);
+	return require_errors.UnknownToolError.is(error) || require_errors.UnknownToolError.is(error === null || error === void 0 ? void 0 : error.cause) || (require_errors.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 = require_quickjs_variant.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 require_errors.CognitiveError("LLM generation failed: missing successful provider metadata");
+	if (metadata.stopReason === "max_tokens") {
+		var _metadata$usage;
+		throw new require_errors.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 require_errors.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 = require_custom_client.countNativeRequestTokens([], []);
+	const requestWithToolsTokens = require_custom_client.countNativeRequestTokens([], tools);
+	const requestWithHistoryTokens = require_custom_client.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 require_errors.CognitiveError("Provider returned invalid assistant output");
+	if (!Array.isArray(calls)) throw new require_errors.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 require_errors.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 require_errors.CognitiveError("Provider returned invalid native tool arguments");
+		ids.add(call.id);
+	}
+	if (assistant) {
+		var _assistant$content;
+		if (assistant.role !== "assistant") throw new require_errors.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 (require_custom_client.stableJSON(normalized) !== require_custom_client.stableJSON(calls)) throw new require_errors.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 require_errors.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 require_errors.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 require_errors.CognitiveError(`Failed to fetch model details for ${ref}: ${require_utils.getErrorMessage(error)}`, { cause: error });
+		}
+	}));
+	const model = models[0];
+	const { limit, output: reserve } = require_custom_client.resolveTokenBudget(models, ctx.maxTokens);
+	const tools = [require_native.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 require_custom_client.prepareAutoCompaction(ctx.session, {
+		client: cognitive,
+		model: iteration.model,
+		signal: controller.signal,
+		contextWindow: ctx.maxTokens,
+		iterationId: iteration.id,
+		inputLimit: limit - reserve,
+		metadata,
+		measure: (ids, summary) => require_custom_client.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 = require_custom_client.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 = require_custom_client.countNativeRequestTokens(messages, tools);
+	}
+	if (tokens > limit - reserve) throw new require_errors.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." : require_native.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 `${require_native.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 `${require_native.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 require_errors.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 require_errors.CognitiveError(`LLM stream restart handler failed: ${require_utils.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 require_errors.CognitiveError(`LLM generation failed: ${value.error}`);
+					if (value.restart) {
+						if (dispatchedCalls) throw new require_errors.CognitiveError("The LLM stream restarted after tool execution began; completed work cannot be replayed.");
+						if (!ctx.midStreamFallback) throw new require_errors.CognitiveError("Unexpected LLM stream restart");
+						if (!Number.isInteger(value.restart.attempt) || value.restart.attempt <= attempt) throw new require_errors.CognitiveError("Provider returned an invalid stream restart attempt");
+						if (value.output || value.toolCalls || value.finished) throw new require_errors.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 ? require_custom_client.stableJSON(value.toolCalls) : void 0;
+					if (dispatchedCalls && callsFingerprint !== void 0 && callsFingerprint !== dispatchedFingerprint) throw new require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.CognitiveError("Provider signaled tool calls but returned none");
+		accepted = true;
+	} catch (err) {
+		throw require_errors.isLLMzError(err) ? err : new require_errors.CognitiveError(`LLM generation failed: ${require_utils.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 = require_quickjs_variant.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();
+	const inspections = [];
+	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 (require_errors.isCriticalError(error)) {
+			criticalFailure = error;
+			complete();
+		}
+	};
+	const throwIfTerminated = () => {
+		if (criticalFailure) throw criticalFailure;
+		if (interruption || terminalOutcome) throw termination;
+	};
+	const assertOpen = () => {
+		throwIfTerminated();
+		if (!open) throw new require_errors.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 = (0, ulid.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 require_errors.UnknownExitError(name, exits.map((exit) => exit.name));
+		if (!registered.schema && value !== void 0) throw new require_errors.ExitInputError(registered.name, [{
+			path: [],
+			message: "This exit takes no payload."
+		}], "undefined");
+		const schema = registered.zSchema;
+		const parsed = schema ? require_schema.parseSchemaSync(schema, value, `Exit "${registered.name}"`) : void 0;
+		if (parsed && !parsed.success) throw new require_errors.ExitInputError(registered.name, parsed.error.issues, require_typings.schemaToTypeScript(schema));
+		const validated = parsed === null || parsed === void 0 ? void 0 : parsed.data;
+		return {
+			type: "exit",
+			exit: registered,
+			value: require_quickjs_variant.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 (require_errors.isCriticalError(error)) {
+				criticalFailure = error;
+				complete();
+			}
+			if (!interruption && require_errors.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 require_errors.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: require_quickjs_variant.cloneMemoryValue(value)
+	});
+	const chat = require_vm.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 require_errors.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,
+		requestInspection: (inspection) => {
+			inspections.push(inspection);
+		},
+		getForcedInspections: () => inspections,
+		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 (require_errors.isCriticalError(err)) {
+			iteration.recordError(err);
+			throw err;
+		}
+		iteration.recordError(new require_errors.HookError(err instanceof Error ? err.message : String(err), { cause: err }));
+		console.error(err);
+	}
+};
+//#endregion
+//#region src/runtime/tool-wrapper.ts
+const SLOW_TOOL_WARNING = (0, ms.default)("15s");
+function wrapTool({ tool, object, iteration, beforeHook, afterHook, onTruncation, onResult, controller, onThink }) {
+	return async function(input, line) {
+		controller.signal.throwIfAborted();
+		const toolCallId = `tcall_${(0, ulid.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;
+		const inspections = [];
+		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 unwrapSignal = (value) => {
+			if (!require_errors.ThinkSignal.is(value)) return value;
+			const context = value.context;
+			const output = require_truncate.unwrapTruncated(context);
+			if (require_truncate.isTruncated(context)) onTruncation === null || onTruncation === void 0 || onTruncation(output, context.$$truncate);
+			const inspection = {
+				tool: object ? `${object}.${tool.name}` : tool.name,
+				toolCallId,
+				line,
+				reason: value.reason,
+				value: output,
+				metadata: value.metadata
+			};
+			inspections.push(inspection);
+			return output;
+		};
+		try {
+			const beforeRes = await callHook(() => beforeHook === null || beforeHook === void 0 ? void 0 : beforeHook({
+				iteration,
+				tool,
+				input: effectiveInput,
+				controller,
+				object,
+				toolCallId,
+				nativeCallId: iteration.nativeCallId
+			}));
+			if (require_errors.ThinkSignal.is(beforeRes)) throw new require_errors.HookError("Tool hooks cannot request inspection with ThinkSignal. Return it from the tool handler instead.");
+			if (typeof (beforeRes === null || beforeRes === void 0 ? void 0 : beforeRes.input) !== "undefined") effectiveInput = beforeRes.input;
+			controller.signal.throwIfAborted();
+			try {
+				output = await tool.execute(effectiveInput, {
+					callId: toolCallId,
+					iterationId: iteration.id,
+					nativeCallId: iteration.nativeCallId,
+					onTruncation,
+					onInput: (parsed) => {
+						controller.signal.throwIfAborted();
+						if (effectiveInput === originalInput) reportedInput = parsed;
+					}
+				});
+			} catch (error) {
+				if (!require_errors.ThinkSignal.is(error)) throw error;
+				output = error;
+			}
+			output = unwrapSignal(output);
+			const afterRes = await callHook(() => afterHook === null || afterHook === void 0 ? void 0 : afterHook({
+				iteration,
+				tool,
+				input: effectiveInput,
+				output,
+				controller,
+				object,
+				toolCallId,
+				nativeCallId: iteration.nativeCallId
+			}));
+			if (require_errors.ThinkSignal.is(afterRes) || require_errors.ThinkSignal.is(afterRes === null || afterRes === void 0 ? void 0 : afterRes.output)) throw new require_errors.HookError("Tool hooks cannot request inspection with ThinkSignal. Return it from the tool handler instead.");
+			if (typeof (afterRes === null || afterRes === void 0 ? void 0 : afterRes.output) !== "undefined") output = afterRes.output;
+			controller.signal.throwIfAborted();
+		} catch (err) {
+			success = false;
+			output = void 0;
+			if (require_errors.ThinkSignal.is(err)) error = new require_errors.HookError("Tool hooks cannot request inspection with ThinkSignal. Return it from the tool handler instead.");
+			else error = require_errors.isLLMzError(err) ? err : new require_errors.ToolExecutionError(tool.name, err);
+			iteration.recordError(error);
+		} finally {
+			clearTimeout(alertSlowTool);
+			for (const inspection of success ? inspections : []) {
+				const value = require_quickjs_variant.snapshotInspectionValue(output);
+				onThink === null || onThink === void 0 || onThink({
+					...inspection,
+					value
+				});
+				iteration.recordTrace({
+					type: "think_signal",
+					started_at: Date.now(),
+					ended_at: Date.now(),
+					line: line ?? 0,
+					tool_name: tool.name,
+					tool_call_id: toolCallId,
+					object,
+					reason: inspection.reason,
+					context: value,
+					metadata: inspection.metadata
+				});
+			}
+			pushToolCallTrace();
+		}
+		if (!success) throw error;
+		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 = {
+		...require_utils.stripInvalidIdentifiers(memoryBindings),
+		[require_vm.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, require_vm.VM_PROGRAM_COMPLETE, { value: javascriptApi.complete });
+		Object.defineProperty(vmContext, require_vm.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 ?? _bpinternal_zui.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 require_errors.AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`));
+					let parsed;
+					try {
+						parsed = require_schema.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 require_errors.ObjectPropertyError(obj.name, name, parsed.error.issues, require_typings.schemaToTypeScript(schema)));
+					internalValues[name] = freezePropertyValue(require_quickjs_variant.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,
+				onThink: javascriptApi === null || javascriptApi === void 0 ? void 0 : javascriptApi.requestInspection
+			});
+			instance[tool.name] = javascriptApi ? (input) => {
+				var _vmContext$VM_CALL_SI;
+				const line = (_vmContext$VM_CALL_SI = vmContext[require_vm.VM_CALL_SITE]) === null || _vmContext$VM_CALL_SI === void 0 ? void 0 : _vmContext$VM_CALL_SI.call(vmContext);
+				return javascriptApi.track(() => wrapped(input, line));
+			} : wrapped;
+		}
+		vmContext[obj.name] = require_vm.withMissingMember(instance, (name) => {
+			const error = new require_errors.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,
+			onThink: javascriptApi === null || javascriptApi === void 0 ? void 0 : javascriptApi.requestInspection
+		});
+		const callable = javascriptApi ? (input) => {
+			var _vmContext$VM_CALL_SI2;
+			const line = (_vmContext$VM_CALL_SI2 = vmContext[require_vm.VM_CALL_SITE]) === null || _vmContext$VM_CALL_SI2 === void 0 ? void 0 : _vmContext$VM_CALL_SI2.call(vmContext);
+			return javascriptApi.track(() => wrapped(input, line));
+		} : 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 require_utils.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 require_custom_client.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 _props$options8, _ctx$iterations$at;
+		if ("snapshot" in props) throw new require_errors.InvalidConfigurationError("Snapshots and external pause/resume are no longer supported. Use a session for conversation history and memory.");
+		if ("messages" in props) throw new require_errors.InvalidConfigurationError("Append input with session.append(message) before calling execute(). execute.messages is no longer supported.");
+		if (((_props$options8 = props.options) === null || _props$options8 === void 0 ? void 0 : _props$options8.requireChatResponse) !== void 0 && typeof props.options.requireChatResponse !== "boolean") throw new require_errors.InvalidConfigurationError("Invalid requireChatResponse. Expected a boolean.");
+		release = ctx.session.acquire();
+		prepareSession(ctx);
+		const client = props.client ?? new _botpress_client.Client();
+		const execution = {
+			ctx,
+			props,
+			cognitive: _botpress_cognitive.Cognitive.isCognitiveClient(client) || require_custom_client._CustomModelClient.isCustomClient(client) ? client : new _botpress_cognitive.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 require_errors.LoopExceededError(ctx.loop);
+		(_ctx$iterations$at = ctx.iterations.at(-1)) === null || _ctx$iterations$at === void 0 || _ctx$iterations$at.recordError(error);
+		return new require_custom_client.ErrorExecutionResult(ctx, error);
+	} catch (error) {
+		return new require_custom_client.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 require_errors.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 require_errors.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 (!require_errors.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 = require_native.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 require_errors.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 = require_native.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 require_errors.CognitiveError(`Could not retract the rejected response: ${require_utils.getErrorMessage(error)}`);
+	}
+	iteration.end({
+		type: "invalid_code_error",
+		invalid_code_error: { message }
+	}, generated.toolCalls.some((call) => call.name !== "run_javascript") ? new require_errors.UnknownToolError(generated.toolCalls.find((call) => call.name !== "run_javascript").name, ["run_javascript"], message) : new require_errors.NativeProtocolError(message));
+}
+async function deliverAssistantText(state, generated) {
+	var _iteration$response4;
+	const { ctx, iteration } = state;
+	if (!generated.output.trim() || !ctx.chat || !((_iteration$response4 = iteration.response) === null || _iteration$response4 === void 0 ? void 0 : _iteration$response4.handler)) return;
+	const startedAt = Date.now();
+	const message = {
+		type: "text",
+		text: generated.output
+	};
+	try {
+		await iteration.response.handler(generated.output.trim(), generated.messageMetadata);
+	} catch (cause) {
+		if (require_errors.isCriticalError(cause)) throw cause;
+		throw new require_errors.DeliveryError(`Assistant response delivery failed: ${require_utils.getErrorMessage(cause)}`, { cause });
+	}
+	ctx.session.recordAssistantDelivery(iteration.id);
+	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;
+	const forcedInspections = api.getForcedInspections();
+	if (forcedInspections.length && !controller.signal.aborted && !require_errors.isCriticalError(result.error)) {
+		if (!result.success && result.error) {
+			iteration.recordError(result.error);
+			state.capture.downstreamError = result.error;
+		}
+		state.capture.forcedInspections = forcedInspections;
+		let value = forcedInspections.length === 1 ? forcedInspections[0].value : forcedInspections.map((entry) => entry.value);
+		if ((outcome === null || outcome === void 0 ? void 0 : outcome.type) === "inspect") value = outcome.value;
+		state.capture.result = {
+			...result,
+			success: true,
+			signal: void 0,
+			return_value: value
+		};
+		iteration.end({
+			type: "thinking_requested",
+			thinking_requested: {
+				reason: "Tools completed successfully and requested forced inspection.",
+				variables: value,
+				metadata: forcedInspections.length === 1 ? forcedInspections[0].metadata : void 0
+			}
+		});
+		return;
+	}
+	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(require_utils.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 } = state;
+	state.memory = commitMemory(state, result, false);
+	try {
+		controller.signal.throwIfAborted();
+		await applyNativeExit(state, outcome.exit, outcome.value);
+	} catch (error) {
+		endFailedIteration(iteration, controller, error);
+	}
+}
+async function deliverJavaScriptMessages({ ctx, iteration, controller }, messages) {
+	if (!messages.length) return;
+	if (!ctx.chat) throw new require_errors.DeliveryError("Component delivery requires chat mode.");
+	for (const message of messages) {
+		controller.signal.throwIfAborted();
+		const startedAt = Date.now();
+		try {
+			if (!require_component.isAnyComponent(message.component)) throw new require_errors.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 require_errors.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: require_utils.getErrorMessage(error),
+				started_at: startedAt,
+				ended_at: Date.now()
+			});
+			throw require_errors.isCriticalError(error) ? error : new require_errors.DeliveryError(`Delivery ${message.id} failed: ${require_utils.getErrorMessage(error)}. Its external outcome is uncertain. Later messages were skipped; earlier acknowledged messages remain delivered.`, { cause: error });
+		}
+		ctx.session.recordAssistantDelivery(iteration.id);
+		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 } = state;
+	if (!generated.toolCalls.length && ctx.chat && (generated.output.trim() || generated.metadata.stopReason === "stop")) {
+		await applyNativeExit(state, require_custom_client.ListenExit, {});
+		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 = `${require_native.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: require_utils.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,
+			forcedInspections: capture === null || capture === void 0 ? void 0 : capture.forcedInspections,
+			downstreamError: capture === null || capture === void 0 ? void 0 : capture.downstreamError
+		};
+	}
+	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 (require_errors.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(require_utils.getErrorMessage(error), {
+			purpose: "error",
+			maxTokens: 200
+		})}. ${outcome} Earlier acknowledged calls remain completed.`);
+	}
+	if (require_errors.isCriticalError(error) || controller.signal.aborted) {
+		state.terminalError = controller.signal.aborted ? new require_errors.ExecutionAbortedError(require_utils.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(require_utils.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: require_utils.getErrorMessage(controller.signal.reason ?? error) }
+		}, new require_errors.ExecutionAbortedError(require_utils.getErrorMessage(controller.signal.reason ?? error), { cause: controller.signal.reason ?? error }));
+		return;
+	}
+	if (require_errors.CognitiveError.is(error) || require_errors.TokenOverflowError.is(error) || require_errors.CompactionError.is(error)) {
+		iteration.end({
+			type: "generation_error",
+			generation_error: { message: error.message }
+		}, error);
+		return;
+	}
+	if (require_errors.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: require_utils.getErrorMessage(error),
+			stack: executionErrorStack(error)
+		}
+	}, error);
+}
+function executionErrorStack(error) {
+	if (require_errors.CodeExecutionError.is(error) && error.stacktrace) return error.stacktrace;
+	if (require_errors.HookError.is(error) && error.cause instanceof Error) return require_errors.cleanStackTrace(error.cause.stack ?? "");
+	if (error instanceof Error) return require_errors.cleanStackTrace(error.stack ?? "");
+	return "";
+}
+function getIterationResult(state) {
+	const { ctx, iteration } = state;
+	const critical = iteration.errors.find(require_errors.isCriticalError);
+	state.terminalError ??= critical;
+	if (state.terminalError !== void 0) return new require_custom_client.ErrorExecutionResult(ctx, state.terminalError);
+	if (iteration.status.type === "exit_success") {
+		const outcome = iteration.status.exit_success;
+		return new require_custom_client.SuccessExecutionResult(ctx, {
+			exit: iteration.exits.find((exit) => exit.name === outcome.exit_name),
+			result: outcome.return_value
+		});
+	}
+	if (iteration.status.type === "aborted") return new require_custom_client.ErrorExecutionResult(ctx, iteration.error);
+}
+async function applyNativeExit(state, exit, value) {
+	const { ctx, iteration, controller, props } = state;
+	try {
+		var _props$options9;
+		if (ctx.chat && exit === require_custom_client.ListenExit && ((_props$options9 = props.options) === null || _props$options9 === void 0 ? void 0 : _props$options9.requireChatResponse) !== false && ctx.session.lastSpeaker !== "assistant") throw new require_errors.MissingChatResponseError("The assistant has not delivered a message since the last user message. Send a response using the inspected results before waiting for the user. Do not repeat completed tool calls.");
+		await callHook(() => {
+			var _props$onExit;
+			return (_props$onExit = props.onExit) === null || _props$onExit === void 0 ? void 0 : _props$onExit.call(props, {
+				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: require_utils.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(require_vm.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 require_vm.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(require_utils.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 (require_errors.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(require_utils.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 (require_errors.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 (require_errors.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
+exports.executeContext = executeContext;