llmz 0.9.0 → 1.0.2

package/dist/execute-BWcdv9so.js

@@ -1,1059 +0,0 @@
-import { a as isEqual, l as toNumber } from "./dual-modes-DDkoCp3R.js";
-import { a as ResponseParser, i as toParsedAssistantResponse } from "./common-BlRFtdf2.js";
-import { d as Snapshot, f as parseExit, l as PartialExecutionResult, n as Context, s as ErrorExecutionResult, t as _CustomModelClient, u as SuccessExecutionResult } from "./custom-client-ChuZ63zp.js";
-import { d as stripInvalidIdentifiers, i as getErrorMessage, s as init } from "./utils-UBeAFeEI.js";
-import { t as createJsxComponent } from "./jsx-CIgdGGVs.js";
-import { t as cleanStackTrace } from "./stack-traces-BIE_5Xwf.js";
-import { a as InvalidCodeError, c as SnapshotSignal, i as CognitiveError, l as ThinkSignal, n as CodeExecutionError, o as LoopExceededError, s as Signals, t as AssignmentError } from "./errors-Cg1G0Awu.js";
-import { n as truncateWrappedContent } from "./truncator-DZqEqnpD.js";
-import { r as hasTopLevelReturn } from "./compiler-CW1VjQsn.js";
-import { runAsyncFunction, warmupVM } from "./vm-BLsHw1da.js";
-import { z } from "@bpinternal/zui";
-import { ulid } from "ulid";
-import { Client } from "@botpress/client";
-import { Cognitive } from "@botpress/cognitive";
-import ms from "ms";
-//#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseClamp.js
-/**
-* The base implementation of `_.clamp` which doesn't coerce arguments.
-*
-* @private
-* @param {number} number The number to clamp.
-* @param {number} [lower] The lower bound.
-* @param {number} upper The upper bound.
-* @returns {number} Returns the clamped number.
-*/
-function baseClamp(number, lower, upper) {
-	if (number === number) {
-		if (upper !== void 0) number = number <= upper ? number : upper;
-		if (lower !== void 0) number = number >= lower ? number : lower;
-	}
-	return number;
-}
-//#endregion
-//#region ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/clamp.js
-/**
-* Clamps `number` within the inclusive `lower` and `upper` bounds.
-*
-* @static
-* @memberOf _
-* @since 4.0.0
-* @category Number
-* @param {number} number The number to clamp.
-* @param {number} [lower] The lower bound.
-* @param {number} upper The upper bound.
-* @returns {number} Returns the clamped number.
-* @example
-*
-* _.clamp(-10, -5, 5);
-* // => -5
-*
-* _.clamp(10, -5, 5);
-* // => 5
-*/
-function clamp(number, lower, upper) {
-	if (upper === void 0) {
-		upper = lower;
-		lower = void 0;
-	}
-	if (upper !== void 0) {
-		upper = toNumber(upper);
-		upper = upper === upper ? upper : 0;
-	}
-	if (lower !== void 0) {
-		lower = toNumber(lower);
-		lower = lower === lower ? lower : 0;
-	}
-	return baseClamp(toNumber(number), lower, upper);
-}
-//#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/runtime/generate.ts
-const RESPONSE_LENGTH_BUFFER = {
-	MIN_TOKENS: 1e3,
-	MAX_TOKENS: 16e3,
-	PERCENTAGE: .1
-};
-/** Maximum time to wait between two stream chunks before considering the stream stalled. */
-const STREAM_INACTIVITY_TIMEOUT = 18e4;
-/** A syntactically valid prefix must not execute when generation did not finish successfully. */
-const assertSuccessfulGeneration = (metadata) => {
-	if (metadata.provider === "unknown") throw new CognitiveError("LLM generation failed: received error metadata with unknown provider");
-	if (metadata.stopReason === "max_tokens" || metadata.stopReason === "content_filter") throw new CognitiveError(`LLM generation did not complete: stopReason=${metadata.stopReason}`);
-};
-const getModelOutputLimit = (inputLength) => clamp(RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength, RESPONSE_LENGTH_BUFFER.MIN_TOKENS, RESPONSE_LENGTH_BUFFER.MAX_TOKENS);
-const generateCode = async ({ iteration, ctx, cognitive, controller, metadata, onSend, onSendDelta, onRunStart }) => {
-	const startedAt = Date.now();
-	const traces = iteration.traces;
-	const modelRef = Array.isArray(iteration.model) ? iteration.model[0] : iteration.model;
-	const model = await cognitive.getModelDetails(modelRef).catch((thrown) => {
-		throw new CognitiveError(`Failed to fetch model details for model "${modelRef}": ${getErrorMessage(thrown)}`);
-	});
-	let modelLimit = Math.max(model.input.maxTokens, 8e3);
-	if (ctx.maxTokens) modelLimit = Math.min(ctx.maxTokens, modelLimit);
-	const responseLengthBuffer = getModelOutputLimit(modelLimit);
-	if (iteration.tokens) iteration.tokens.limit = modelLimit;
-	let messages;
-	try {
-		messages = truncateWrappedContent({
-			messages: iteration.messages,
-			tokenLimit: modelLimit - responseLengthBuffer,
-			throwOnFailure: true
-		}).filter((x) => typeof x.content !== "string" || x.content.trim().length > 0);
-	} catch (thrown) {
-		const cap = ctx.maxTokens ? ` (context window capped at ${modelLimit} tokens by options.maxTokens — consider raising or removing it)` : ` (model context window: ${modelLimit} tokens)`;
-		throw new CognitiveError(`The prompt does not fit in the context window${cap}: ${getErrorMessage(thrown)}`);
-	}
-	iteration.messages = messages;
-	traces.push({
-		type: "llm_call_started",
-		started_at: startedAt,
-		ended_at: startedAt,
-		model: model.id
-	});
-	const hasAudioParts = messages.some((message) => Array.isArray(message.content) && message.content.some((part) => part.type === "audio"));
-	const input = {
-		model: iteration.model,
-		temperature: iteration.temperature,
-		responseFormat: "text",
-		reasoningEffort: iteration.reasoningEffort,
-		messages,
-		stopSequences: ctx.version.getStopTokens(),
-		meta: metadata ? { metadata } : void 0,
-		options: hasAudioParts ? { transcriptionModel: ctx.transcriptionModel ?? "fast" } : void 0
-	};
-	let responseMetadata;
-	let raw;
-	let assistantResponse;
-	/** Milliseconds between the stream request and the first/last streamed tokens. */
-	let timeToFirstToken;
-	let timeToLastToken;
-	const midStreamFallback = ctx.midStreamFallback === true;
-	let attempt = 1;
-	const messageMetadata = (itemId) => ({
-		iterationId: iteration.id,
-		id: midStreamFallback ? `${iteration.id}:${attempt}:${itemId}` : `${iteration.id}:${itemId}`
-	});
-	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)}`);
-		}
-	};
-	const liveItems = /* @__PURE__ */ new Map();
-	const liveContent = /* @__PURE__ */ new Map();
-	let codeGenerationTraced = false;
-	let runCompleted = false;
-	let completions = [];
-	const dispatchSends = async (events) => {
-		for (const event of events) if (event.type === "item-start") {
-			liveItems.set(event.item.id, event.item);
-			if (event.item.kind === "run" && !codeGenerationTraced) {
-				codeGenerationTraced = true;
-				traces.push({
-					type: "code_generation_started",
-					started_at: Date.now()
-				});
-				onRunStart === null || onRunStart === void 0 || onRunStart();
-			}
-		} else if (event.type === "body-delta" && onSendDelta) {
-			const item = liveItems.get(event.itemId);
-			if ((item === null || item === void 0 ? void 0 : item.kind) !== "send" || runCompleted) continue;
-			const content = (liveContent.get(item.id) ?? "") + event.delta;
-			liveContent.set(item.id, content);
-			const delta = {
-				restart: false,
-				...messageMetadata(item.id),
-				component: item.name,
-				props: item.props,
-				delta: event.delta,
-				content
-			};
-			await preview(delta);
-		} else if (event.type === "item-complete") {
-			if (event.item.kind === "send" && onSend && !runCompleted) {
-				const send = {
-					name: event.item.name,
-					props: event.item.props,
-					body: event.item.body
-				};
-				const metadata = messageMetadata(event.item.id);
-				completions.push(() => onSend(send, metadata));
-			} else if (event.item.kind === "run" && event.item.status === "complete" && !runCompleted) runCompleted = true;
-		}
-	};
-	if (typeof cognitive.generateTextStream === "function") {
-		let parser = new ResponseParser();
-		const streamController = createJoinedAbortController([controller.signal]);
-		const requestedAt = Date.now();
-		const stream = cognitive.generateTextStream({
-			...input,
-			...ctx.maxTimeToFirstToken || midStreamFallback ? { options: {
-				...input.options,
-				...ctx.maxTimeToFirstToken ? { maxTimeToFirstToken: ctx.maxTimeToFirstToken } : {},
-				...midStreamFallback ? { midStreamFallback: true } : {}
-			} } : {}
-		}, { signal: streamController.signal });
-		const inactivityTimeout = Math.max(STREAM_INACTIVITY_TIMEOUT, ctx.maxTimeToFirstToken ?? 0);
-		const nextChunk = async () => {
-			let timer;
-			const stalled = new Promise((_, reject) => {
-				timer = setTimeout(() => {
-					streamController.abort("LLM stream stalled");
-					reject(/* @__PURE__ */ new Error(`LLM stream stalled: no data received for ${inactivityTimeout}ms`));
-				}, inactivityTimeout);
-			});
-			try {
-				return await Promise.race([stream.next(), stalled]);
-			} finally {
-				clearTimeout(timer);
-			}
-		};
-		raw = "";
-		let streamCompleted = false;
-		let accepted = false;
-		try {
-			while (true) {
-				var _chunk$value, _chunk$value2, _chunk$value3, _chunk$value4;
-				let chunk;
-				try {
-					chunk = await nextChunk();
-				} catch (thrown) {
-					throw new CognitiveError(`LLM generation failed: ${getErrorMessage(thrown)}`);
-				}
-				if (chunk.done) {
-					streamCompleted = true;
-					break;
-				}
-				if (((_chunk$value = chunk.value) === null || _chunk$value === void 0 ? void 0 : _chunk$value.restart) && !midStreamFallback) {
-					streamController.abort("Unexpected LLM stream restart");
-					throw new CognitiveError("LLM stream restarted without options.midStreamFallback enabled");
-				}
-				if ((_chunk$value2 = chunk.value) === null || _chunk$value2 === void 0 ? void 0 : _chunk$value2.restart) {
-					traces.push({
-						type: "llm_call_restarted",
-						started_at: Date.now(),
-						...chunk.value.restart
-					});
-					raw = "";
-					completions = [];
-					accepted = false;
-					parser = new ResponseParser();
-					liveItems.clear();
-					liveContent.clear();
-					codeGenerationTraced = false;
-					runCompleted = false;
-					responseMetadata = void 0;
-					attempt = chunk.value.restart.attempt;
-					await preview({
-						...chunk.value.restart,
-						restart: true,
-						iterationId: iteration.id
-					});
-					timeToFirstToken = void 0;
-					timeToLastToken = void 0;
-					continue;
-				}
-				if ((_chunk$value3 = chunk.value) === null || _chunk$value3 === void 0 ? void 0 : _chunk$value3.metadata) responseMetadata = chunk.value.metadata;
-				const delta = (_chunk$value4 = chunk.value) === null || _chunk$value4 === void 0 ? void 0 : _chunk$value4.output;
-				if (!delta) continue;
-				timeToLastToken = Date.now() - requestedAt;
-				timeToFirstToken ??= timeToLastToken;
-				raw += delta;
-				await dispatchSends(parser.push(delta));
-			}
-			if (!responseMetadata) throw new CognitiveError("LLM streaming completed without metadata");
-			assertSuccessfulGeneration(responseMetadata);
-			await dispatchSends(parser.finish(responseMetadata.stopReason));
-			if (parser.valid) {
-				for (const complete of completions) await complete();
-				accepted = true;
-			}
-			assistantResponse = toParsedAssistantResponse(parser.items, raw, parser.diagnostics);
-		} catch (error) {
-			parser.finish();
-			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: "error",
-				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) ?? usage.inputCost + usage.outputCost,
-				output: raw,
-				diagnostics: parser.diagnostics,
-				model: (responseMetadata === null || responseMetadata === void 0 ? void 0 : responseMetadata.model) ?? model.id,
-				time_to_first_token: timeToFirstToken,
-				time_to_last_token: timeToLastToken,
-				usage
-			};
-			throw error;
-		} finally {
-			streamController.abort("LLM stream closed");
-			if (!streamCompleted) stream.return(void 0).catch((err) => {});
-			if (!accepted && liveContent.size) await preview({
-				restart: true,
-				iterationId: iteration.id,
-				attempt: attempt + 1,
-				fromModel: model.id,
-				toModel: model.id,
-				reason: "invalid or incomplete response envelope"
-			});
-		}
-		controller.signal.throwIfAborted();
-	} else {
-		const response = await cognitive.generateText(input, { signal: controller.signal }).catch((thrown) => {
-			throw new CognitiveError(`LLM generation failed: ${getErrorMessage(thrown)}`);
-		});
-		if (response.error) throw new CognitiveError(`LLM generation failed: ${response.error}`);
-		if (!response.output) throw new CognitiveError("LLM did not return any text output");
-		responseMetadata = response.metadata;
-		assertSuccessfulGeneration(responseMetadata);
-		raw = response.output;
-		assistantResponse = ctx.version.parseAssistantResponse(raw, responseMetadata.stopReason);
-		for (const [index, send] of assistantResponse.sends.entries()) await (onSend === null || onSend === void 0 ? void 0 : onSend(send, messageMetadata(`send-${index}`)));
-	}
-	iteration.code = assistantResponse.code;
-	iteration.sends = assistantResponse.sends;
-	iteration.next = assistantResponse.next;
-	const usage = responseMetadata.usage;
-	iteration.llm = {
-		cached: responseMetadata.cached || false,
-		ended_at: Date.now(),
-		started_at: startedAt,
-		status: "success",
-		tokens: usage.inputTokens + usage.outputTokens,
-		spend: responseMetadata.cost ?? usage.inputCost + usage.outputCost,
-		output: assistantResponse.raw,
-		diagnostics: assistantResponse.diagnostics,
-		model: `${responseMetadata.provider}:${responseMetadata.model}`,
-		time_to_first_token: timeToFirstToken,
-		time_to_last_token: timeToLastToken,
-		usage: {
-			inputTokens: usage.inputTokens,
-			inputCost: usage.inputCost,
-			outputTokens: usage.outputTokens,
-			outputCost: usage.outputCost
-		}
-	};
-	if (iteration.tokens) {
-		iteration.tokens.input = usage.inputTokens;
-		iteration.tokens.output = usage.outputTokens;
-		iteration.tokens.total = usage.inputTokens + usage.outputTokens;
-	}
-	traces.push({
-		type: "llm_call_success",
-		started_at: startedAt,
-		ended_at: iteration.llm.ended_at,
-		model: iteration.llm.model,
-		code: iteration.code ?? ""
-	});
-};
-//#endregion
-//#region src/runtime/interpret-result.ts
-const interpretVMResult = async ({ iteration, result, controller, startedAt, onExit }) => {
-	Object.assign(iteration.variables, Object.fromEntries(Object.entries(result.variables ?? {}).filter(([, value]) => value !== "[[non-primitive]]")));
-	if (result.error && result.error instanceof InvalidCodeError) {
-		iteration.end({
-			type: "invalid_code_error",
-			invalid_code_error: { message: result.error.message }
-		});
-		return;
-	}
-	iteration.traces.push({
-		type: "code_execution",
-		lines_executed: result.lines_executed ?? 0,
-		started_at: startedAt,
-		ended_at: Date.now()
-	});
-	if (controller.signal.aborted) {
-		iteration.end({
-			type: "aborted",
-			aborted: { reason: controller.signal.reason ?? "The operation was aborted" }
-		});
-		return;
-	}
-	if (result.error && result.error instanceof CodeExecutionError) {
-		iteration.end({
-			type: "execution_error",
-			execution_error: {
-				message: result.error.message,
-				stack: cleanStackTrace(result.error.stacktrace ?? result.error.stack ?? "No stack trace available")
-			}
-		});
-		return;
-	}
-	if (!result.success) {
-		var _result$error;
-		iteration.end({
-			type: "execution_error",
-			execution_error: {
-				message: (result === null || result === void 0 || (_result$error = result.error) === null || _result$error === void 0 ? void 0 : _result$error.message) ?? "Unknown error occurred",
-				stack: cleanStackTrace(result.error.stack ?? "No stack trace available")
-			}
-		});
-		return;
-	}
-	if (result.signal instanceof ThinkSignal) {
-		iteration.end({
-			type: "thinking_requested",
-			thinking_requested: {
-				variables: result.signal.context,
-				reason: result.signal.reason,
-				metadata: result.signal.metadata,
-				interrupted: true
-			}
-		});
-		return;
-	}
-	if (result.signal instanceof SnapshotSignal) {
-		iteration.end({
-			type: "callback_requested",
-			callback_requested: { signal: result.signal }
-		});
-		return;
-	}
-	const returnValue = result.return_value;
-	const codeRequestsInspection = hasTopLevelReturn(iteration.code ?? "");
-	if (iteration.next && !codeRequestsInspection) {
-		await applyNextExit({
-			iteration,
-			controller,
-			onExit
-		});
-		return;
-	}
-	const localVariables = Object.fromEntries(Object.entries(result.variables ?? {}).filter(([, value]) => value !== "[[non-primitive]]"));
-	iteration.end({
-		type: "thinking_requested",
-		thinking_requested: {
-			reason: iteration.next ? `Code execution completed. The ■next=${iteration.next.name} exit was NOT applied because your code returns a value — inspect it below, then end your next response with ■next.` : "Code execution completed",
-			variables: returnValue !== void 0 ? returnValue : Object.keys(localVariables).length ? localVariables : iteration.variables
-		}
-	});
-};
-/**
-* Applies the `■next=<exit>` block of the current iteration: validates the exit
-* name and props against the available exits, runs the onExit hook, and ends
-* the iteration with exit_success or exit_error.
-*/
-const applyNextExit = async ({ iteration, controller, onExit }) => {
-	const next = iteration.next;
-	if (!next) throw new Error("applyNextExit called without a ■next block on the iteration");
-	const attempt = (props) => parseExit(Object.keys(props).length ? {
-		action: next.name,
-		value: props
-	} : { action: next.name }, iteration.exits);
-	let parsedExit = attempt(next.props);
-	const keys = Object.keys(next.props);
-	if (!parsedExit.success && keys.length === 1 && [
-		"props",
-		"value",
-		"data"
-	].includes(keys[0])) {
-		const inner = next.props[keys[0]];
-		if (inner && typeof inner === "object" && !Array.isArray(inner)) {
-			const unwrapped = attempt(inner);
-			if (unwrapped.success) parsedExit = unwrapped;
-		}
-	}
-	const returnValue = {
-		action: next.name,
-		value: parsedExit.success ? parsedExit.value : next.props
-	};
-	if (!parsedExit.success) {
-		var _parsedExit$validatio;
-		const details = (_parsedExit$validatio = parsedExit.validationErrors) === null || _parsedExit$validatio === void 0 ? void 0 : _parsedExit$validatio.join("; ");
-		const error = [parsedExit.error.split("\n")[0], details].filter(Boolean).join(". ");
-		iteration.end({
-			type: "exit_error",
-			exit_error: {
-				exit: next.name,
-				message: `${error}. Received props: ${JSON.stringify(next.props)}. Choose an exit from <exits> and supply its required props as ONE JSON object on the SAME LINE as ■next=${next.name}. Do not use a JavaScript return statement or wrap the fields in "value" or "props".`,
-				return_value: returnValue
-			}
-		});
-		return;
-	}
-	const returnExit = parsedExit.exit;
-	try {
-		await (onExit === null || onExit === void 0 ? void 0 : onExit({
-			exit: returnExit,
-			result: parsedExit.value
-		}, controller));
-	} catch (err) {
-		iteration.end({
-			type: "exit_error",
-			exit_error: {
-				exit: returnExit.name,
-				message: `Error executing exit ${returnExit.name}: ${getErrorMessage(err)}`,
-				return_value: returnValue
-			}
-		});
-		return;
-	}
-	iteration.end({
-		type: "exit_success",
-		exit_success: {
-			exit_name: returnExit.name,
-			return_value: parsedExit.value
-		}
-	});
-};
-//#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) {
-		console.error(err);
-	}
-};
-//#endregion
-//#region src/runtime/tool-wrapper.ts
-const SLOW_TOOL_WARNING = ms("15s");
-function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook, controller }) {
-	const getToolInput = (input) => tool.zInput.safeParse(input).data ?? input;
-	return async function(input) {
-		const toolCallId = `tcall_${ulid()}`;
-		const originalInput = input;
-		let effectiveInput = input;
-		const alertSlowTool = setTimeout(() => traces.push({
-			type: "tool_slow",
-			tool_name: tool.name,
-			tool_call_id: toolCallId,
-			started_at: Date.now(),
-			input: getToolInput(originalInput),
-			object,
-			duration: SLOW_TOOL_WARNING
-		}), SLOW_TOOL_WARNING);
-		const toolStart = Date.now();
-		let output;
-		let error;
-		let success = true;
-		let signalToThrow;
-		const pushToolCallTrace = () => {
-			traces.push({
-				type: "tool_call",
-				tool_call_id: toolCallId,
-				started_at: toolStart,
-				ended_at: Date.now(),
-				tool_name: tool.name,
-				object,
-				input: getToolInput(originalInput),
-				output,
-				error,
-				success
-			});
-		};
-		const handleSignals = async (err) => {
-			if (output === err) return true;
-			if (err instanceof SnapshotSignal) {
-				err.toolCall = {
-					name: tool.name,
-					inputSchema: tool.input,
-					outputSchema: tool.output,
-					input: originalInput
-				};
-				err.message = Signals.serializeError(err);
-			}
-			if (err instanceof ThinkSignal) {
-				signalToThrow = err;
-				traces.push({
-					type: "think_signal",
-					started_at: Date.now(),
-					line: 0,
-					ended_at: Date.now()
-				});
-				success = true;
-				output = err;
-				const afterRes = await (afterHook === null || afterHook === void 0 ? void 0 : afterHook({
-					iteration,
-					tool,
-					input: originalInput,
-					output,
-					controller,
-					object,
-					toolCallId
-				}));
-				if (typeof (afterRes === null || afterRes === void 0 ? void 0 : afterRes.output) !== "undefined") output = afterRes.output;
-				return true;
-			}
-			return false;
-		};
-		try {
-			const beforeRes = await (beforeHook === null || beforeHook === void 0 ? void 0 : beforeHook({
-				iteration,
-				tool,
-				input: effectiveInput,
-				controller,
-				object,
-				toolCallId
-			}));
-			if (typeof (beforeRes === null || beforeRes === void 0 ? void 0 : beforeRes.input) !== "undefined") effectiveInput = beforeRes.input;
-			output = await tool.execute(effectiveInput, {
-				callId: toolCallId,
-				iterationId: iteration.id
-			}, chat);
-			const afterRes = await (afterHook === null || afterHook === void 0 ? void 0 : afterHook({
-				iteration,
-				tool,
-				input: effectiveInput,
-				output,
-				controller,
-				object,
-				toolCallId
-			}));
-			if (typeof (afterRes === null || afterRes === void 0 ? void 0 : afterRes.output) !== "undefined") output = afterRes.output;
-		} catch (err) {
-			if (!await handleSignals(err)) {
-				success = false;
-				error = err;
-			}
-		} finally {
-			clearTimeout(alertSlowTool);
-			pushToolCallTrace();
-		}
-		if (!success) throw error;
-		if (signalToThrow) throw signalToThrow;
-		return output;
-	};
-}
-//#endregion
-//#region src/runtime/vm-context.ts
-const buildVMContext = ({ ctx, iteration, controller, onBeforeTool, onAfterTool }) => {
-	const traces = iteration.traces;
-	const vmContext = { ...stripInvalidIdentifiers(iteration.variables) };
-	for (const obj of iteration.objects) {
-		const internalValues = {};
-		const instance = {};
-		for (const { name, value, writable, type } of obj.properties ?? []) {
-			internalValues[name] = value;
-			const initialValue = value;
-			const schema = type ?? z.any();
-			Object.defineProperty(instance, name, {
-				enumerable: true,
-				configurable: true,
-				get() {
-					return internalValues[name];
-				},
-				set(value) {
-					if (isEqual(value, internalValues[name])) return;
-					if (!writable) throw new AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`);
-					const parsed = schema.safeParse(value);
-					if (!parsed.success) throw new AssignmentError(`Invalid value for Object property ${obj.name}.${name}: ${getErrorMessage(parsed.error)}`);
-					internalValues[name] = parsed.data;
-					traces.push({
-						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 ?? []) instance[tool.name] = wrapTool({
-			chat: ctx.chat,
-			tool,
-			traces,
-			object: obj.name,
-			iteration,
-			beforeHook: onBeforeTool,
-			afterHook: onAfterTool,
-			controller
-		});
-		Object.preventExtensions(instance);
-		Object.seal(instance);
-		vmContext[obj.name] = instance;
-	}
-	for (const tool of iteration.tools) {
-		const wrapped = wrapTool({
-			chat: ctx.chat,
-			tool,
-			traces,
-			iteration,
-			beforeHook: onBeforeTool,
-			afterHook: onAfterTool,
-			controller
-		});
-		for (const key of [tool.name, ...tool.aliases ?? []]) vmContext[key] = wrapped;
-	}
-	return vmContext;
-};
-//#endregion
-//#region src/runtime/execute.ts
-const executeContext = async (props) => {
-	await init();
-	const result = await executeContextInternal(props);
-	try {
-		var _result$context$chat, _result$context$chat$;
-		(_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 || _result$context$chat$.call(_result$context$chat, result);
-	} catch (err) {}
-	return result;
-};
-const executeContextInternal = async (props) => {
-	var _props$options, _props$options2, _props$options3, _props$options4, _props$options5, _props$options6;
-	const controller = createJoinedAbortController([props.signal]);
-	const { onIterationStart, onIterationEnd, onTrace, onExit, onBeforeExecution, onAfterTool, onBeforeTool } = props;
-	const client = props.client ?? new Client();
-	const cognitive = Cognitive.isCognitiveClient(client) || _CustomModelClient.isCustomClient(client) ? client : new Cognitive({ client });
-	const ctx = new Context({
-		chat: props.chat,
-		instructions: props.instructions,
-		examples: props.examples,
-		objects: props.objects,
-		tools: props.tools,
-		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,
-		maxTimeToFirstToken: (_props$options4 = props.options) === null || _props$options4 === void 0 ? void 0 : _props$options4.maxTimeToFirstToken,
-		midStreamFallback: (_props$options5 = props.options) === null || _props$options5 === void 0 ? void 0 : _props$options5.midStreamFallback,
-		transcriptionModel: (_props$options6 = props.options) === null || _props$options6 === void 0 ? void 0 : _props$options6.transcriptionModel,
-		exits: props.exits,
-		snapshot: props.snapshot,
-		model: props.model,
-		temperature: props.temperature,
-		reasoningEffort: props.reasoningEffort
-	});
-	try {
-		while (true) {
-			if (ctx.iterations.length >= ctx.loop) return new ErrorExecutionResult(ctx, new LoopExceededError());
-			const iteration = await ctx.nextIteration();
-			const unsubscribeTrace = iteration.traces.onPush((traces) => {
-				for (const trace of traces) onTrace === null || onTrace === void 0 || onTrace({
-					trace,
-					iteration: ctx.iterations.length,
-					controller
-				});
-			});
-			try {
-				if ((await executeIterationStartHook({
-					ctx,
-					iteration,
-					controller,
-					onIterationStart,
-					onIterationEnd
-				})).type === "continue") continue;
-				if (controller.signal.aborted) {
-					await finalizeIteration({
-						iteration,
-						controller,
-						onIterationEnd,
-						status: {
-							type: "aborted",
-							aborted: { reason: controller.signal.reason ?? "The operation was aborted" }
-						}
-					});
-					return new ErrorExecutionResult(ctx, controller.signal.reason ?? "The operation was aborted");
-				}
-				const iterationResult = await executeIterationWithErrorHandling({
-					iteration,
-					ctx,
-					cognitive,
-					controller,
-					onExit,
-					onBeforeExecution,
-					onAfterTool,
-					onBeforeTool,
-					onIterationEnd,
-					metadata: props.metadata
-				});
-				if (iterationResult.type === "return") return iterationResult.result;
-				const selectedResult = transformIterationResult({
-					ctx,
-					iteration
-				});
-				if (selectedResult.type === "continue") continue;
-				return selectedResult.result;
-			} finally {
-				try {
-					unsubscribeTrace();
-				} catch (err) {}
-			}
-		}
-	} catch (error) {
-		return new ErrorExecutionResult(ctx, error ?? "Unknown error");
-	}
-};
-const executeIterationStartHook = async ({ ctx, iteration, controller, onIterationStart, onIterationEnd }) => {
-	try {
-		const hookRes = await (onIterationStart === null || onIterationStart === void 0 ? void 0 : onIterationStart(iteration, controller, ctx));
-		if (hookRes) Object.assign(iteration, hookRes);
-		return { type: "proceed" };
-	} catch (err) {
-		await finalizeIteration({
-			iteration,
-			controller,
-			onIterationEnd,
-			status: err instanceof ThinkSignal ? {
-				type: "thinking_requested",
-				thinking_requested: {
-					variables: err.context,
-					reason: err.reason
-				}
-			} : {
-				type: "execution_error",
-				execution_error: {
-					message: `Error in onIterationStart hook: ${getErrorMessage(err)}`,
-					stack: cleanStackTrace(err instanceof Error ? err.stack ?? "No stack trace available" : "No stack trace available")
-				}
-			}
-		});
-		return { type: "continue" };
-	}
-};
-const executeIterationWithErrorHandling = async ({ iteration, ctx, cognitive, controller, onExit, onBeforeExecution, onAfterTool, onBeforeTool, onIterationEnd, metadata }) => {
-	try {
-		await executeIteration({
-			iteration,
-			ctx,
-			cognitive,
-			controller,
-			onExit,
-			onBeforeExecution,
-			onAfterTool,
-			onBeforeTool,
-			metadata
-		});
-		await finalizeIteration({
-			iteration,
-			controller,
-			onIterationEnd
-		});
-		return { type: "proceed" };
-	} catch (err) {
-		if (!(err instanceof CognitiveError)) {
-			await finalizeIteration({
-				iteration,
-				controller,
-				onIterationEnd,
-				status: iteration.status.type === "pending" ? {
-					type: "execution_error",
-					execution_error: {
-						message: "An unexpected error occurred: " + getErrorMessage(err),
-						stack: cleanStackTrace(err instanceof Error ? err.stack ?? "No stack trace available" : "No stack trace available")
-					}
-				} : void 0
-			});
-			return { type: "proceed" };
-		}
-		if (!controller.signal.aborted) return {
-			type: "return",
-			result: new ErrorExecutionResult(ctx, err)
-		};
-		await finalizeIteration({
-			iteration,
-			controller,
-			onIterationEnd,
-			status: iteration.status.type === "pending" ? {
-				type: "aborted",
-				aborted: { reason: controller.signal.reason ?? "The operation was aborted" }
-			} : void 0
-		});
-		return {
-			type: "return",
-			result: new ErrorExecutionResult(ctx, controller.signal.reason ?? "The operation was aborted")
-		};
-	}
-};
-const transformIterationResult = ({ ctx, iteration }) => {
-	if (iteration.status.type === "exit_success") {
-		const exitName = iteration.status.exit_success.exit_name;
-		return {
-			type: "return",
-			result: new SuccessExecutionResult(ctx, {
-				exit: iteration.exits.find((x) => x.name === exitName),
-				result: iteration.status.exit_success.return_value
-			})
-		};
-	}
-	if (iteration.status.type === "callback_requested") return {
-		type: "return",
-		result: new PartialExecutionResult(ctx, iteration.status.callback_requested.signal, Snapshot.fromSignal(iteration.status.callback_requested.signal))
-	};
-	if (iteration.status.type === "aborted") return {
-		type: "return",
-		result: new ErrorExecutionResult(ctx, iteration.error ?? "The operation was aborted")
-	};
-	if (iteration.status.type === "thinking_requested" || iteration.status.type === "exit_error" || iteration.status.type === "execution_error" || iteration.status.type === "invalid_code_error") return { type: "continue" };
-	return {
-		type: "return",
-		result: new ErrorExecutionResult(ctx, iteration.error ?? `Unknown error. Status: ${iteration.status.type}`)
-	};
-};
-const executeIteration = async ({ iteration, ctx, cognitive, controller, onExit, onBeforeExecution, onBeforeTool, onAfterTool, metadata }) => {
-	var _ctx$chat;
-	const runCode = (code) => {
-		const vmContext = buildVMContext({
-			ctx,
-			iteration,
-			controller,
-			onBeforeTool,
-			onAfterTool
-		});
-		return runAsyncFunction(vmContext, code, iteration.traces, controller.signal, ctx.timeout).catch((err) => {
-			return {
-				success: false,
-				error: err instanceof Error ? err : new Error(getErrorMessage(err)),
-				lines_executed: [],
-				traces: [],
-				variables: {}
-			};
-		});
-	};
-	await generateCode({
-		iteration,
-		ctx,
-		cognitive,
-		controller,
-		metadata,
-		onRunStart: () => warmupVM(),
-		onSend: async (send, messageMetadata) => {
-			if (!ctx.chat) return;
-			const sendStartedAt = Date.now();
-			const registered = iteration.components.find((component) => component.definition.name.toLowerCase() === send.name);
-			const children = send.body ? [send.body] : [];
-			const component = registered ? registered.render(send.props, children) : createJsxComponent({
-				type: send.name,
-				props: send.props,
-				children
-			});
-			try {
-				await ctx.chat.handler(component, messageMetadata);
-			} catch (err) {
-				throw new Error(`Error while sending message (■send=${send.name}): ${getErrorMessage(err)}`);
-			}
-			iteration.traces.push({
-				type: "yield",
-				value: component,
-				started_at: sendStartedAt,
-				ended_at: Date.now()
-			});
-		},
-		onSendDelta: ((_ctx$chat = ctx.chat) === null || _ctx$chat === void 0 ? void 0 : _ctx$chat.onMessageDelta) ? (delta) => ctx.chat.onMessageDelta(delta) : void 0
-	});
-	if (typeof onBeforeExecution === "function") try {
-		const hookRes = await onBeforeExecution(iteration, controller);
-		if (typeof (hookRes === null || hookRes === void 0 ? void 0 : hookRes.code) === "string" && hookRes.code.trim().length > 0) iteration.code = hookRes.code.trim();
-	} catch (err) {
-		if (err instanceof ThinkSignal) {
-			iteration.end({
-				type: "thinking_requested",
-				thinking_requested: {
-					variables: err.context,
-					reason: err.reason
-				}
-			});
-			return;
-		}
-		iteration.end({
-			type: "execution_error",
-			execution_error: {
-				message: `Error in onBeforeExecution hook: ${getErrorMessage(err)}`,
-				stack: cleanStackTrace(err instanceof Error ? err.stack ?? "No stack trace available" : "No stack trace available")
-			}
-		});
-		return;
-	}
-	const traces = iteration.traces;
-	if (controller.signal.aborted) {
-		traces.push({
-			type: "abort_signal",
-			started_at: Date.now(),
-			reason: "The operation was aborted by user."
-		});
-		iteration.end({
-			type: "aborted",
-			aborted: { reason: controller.signal.reason ?? "The operation was aborted" }
-		});
-		return;
-	}
-	if (!iteration.code) {
-		var _iteration$llm;
-		if (iteration.next) {
-			await applyNextExit({
-				iteration,
-				controller,
-				onExit
-			});
-			return;
-		}
-		iteration.end({
-			type: "invalid_code_error",
-			invalid_code_error: { message: ((_iteration$llm = iteration.llm) === null || _iteration$llm === void 0 || (_iteration$llm = _iteration$llm.diagnostics) === null || _iteration$llm === void 0 || (_iteration$llm = _iteration$llm.find((diagnostic) => diagnostic.code === "invalid-envelope")) === null || _iteration$llm === void 0 ? void 0 : _iteration$llm.message) ?? "The response did not include a ■run block or a ■next exit. Reply with ■start, the required ■ blocks, and ■end." }
-		});
-		return;
-	}
-	const startedAt = Date.now();
-	const result = await runCode(iteration.code);
-	await interpretVMResult({
-		iteration,
-		result,
-		controller,
-		startedAt,
-		onExit
-	});
-};
-//#endregion
-export { executeContext };