llmz 0.6.0 → 0.6.2

package/dist/execute-BEaq3jkV.cjs

@@ -0,0 +1,1003 @@
+const require__baseForOwn = require("./_baseForOwn-buOZDFbK.cjs");
+const require_dual_modes = require("./dual-modes-wAOAlaBS.cjs");
+const require_custom_client = require("./custom-client-BPmEoWKu.cjs");
+const require_utils = require("./utils-ZpJm00ed.cjs");
+const require_jsx = require("./jsx-BWvT6ukg.cjs");
+const require_stack_traces = require("./stack-traces-ntw_qhoy.cjs");
+const require_errors = require("./errors-C962uJdS.cjs");
+const require_truncator = require("./truncator-B6aaJaN1.cjs");
+const require_vm = require("./vm-BjkJqSQH.cjs");
+let _bpinternal_zui = require("@bpinternal/zui");
+let ulid = require("ulid");
+let _botpress_client = require("@botpress/client");
+let _botpress_cognitive = require("@botpress/cognitive");
+let ms = require("ms");
+ms = require__baseForOwn.__toESM(ms, 1);
+//#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 = require_dual_modes.toNumber(upper);
+		upper = upper === upper ? upper : 0;
+	}
+	if (lower !== void 0) {
+		lower = require_dual_modes.toNumber(lower);
+		lower = lower === lower ? lower : 0;
+	}
+	return baseClamp(require_dual_modes.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 = 6e4;
+const getModelOutputLimit = (inputLength) => clamp(RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength, RESPONSE_LENGTH_BUFFER.MIN_TOKENS, RESPONSE_LENGTH_BUFFER.MAX_TOKENS);
+/**
+* Models sometimes wrap their whole response in a code fence. The fence has to
+* be removed before it reaches the incremental parser, otherwise it would be
+* recovered as an unexpected-text message. Works on arbitrary chunk boundaries
+* by holding content back until the first newline.
+*/
+var LeadingFenceFilter = class {
+	_buffer = "";
+	_done = false;
+	push(text) {
+		if (this._done) return text;
+		this._buffer += text;
+		const newline = this._buffer.indexOf("\n");
+		if (newline === -1) return "";
+		this._done = true;
+		const firstLine = this._buffer.slice(0, newline);
+		const rest = this._buffer.slice(newline + 1);
+		this._buffer = "";
+		return firstLine.trim().startsWith("```") ? rest : `${firstLine}\n${rest}`;
+	}
+	flush() {
+		if (this._done) return "";
+		this._done = true;
+		const buffered = this._buffer;
+		this._buffer = "";
+		return buffered.trim().startsWith("```") ? "" : buffered;
+	}
+};
+const generateCode = async ({ iteration, ctx, cognitive, controller, metadata, onSend, onSendDelta, onRunStart, onRunComplete }) => {
+	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 require_errors.CognitiveError(`Failed to fetch model details for model "${modelRef}": ${require_utils.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 = require_truncator.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 require_errors.CognitiveError(`The prompt does not fit in the context window${cap}: ${require_utils.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 liveItems = /* @__PURE__ */ new Map();
+	const liveContent = /* @__PURE__ */ new Map();
+	let codeGenerationTraced = false;
+	let runCompleted = false;
+	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") continue;
+			const content = (liveContent.get(item.id) ?? "") + event.delta;
+			liveContent.set(item.id, content);
+			try {
+				await onSendDelta({
+					id: `${iteration.id}:${item.id}`,
+					component: item.name,
+					props: item.props,
+					delta: event.delta,
+					content
+				});
+			} catch (err) {}
+		} else if (event.type === "item-complete") {
+			if (event.item.kind === "send" && onSend) await onSend({
+				name: event.item.name,
+				props: event.item.props,
+				body: event.item.body
+			});
+			else if (event.item.kind === "run" && event.item.status === "complete" && !runCompleted) {
+				runCompleted = true;
+				onRunComplete === null || onRunComplete === void 0 || onRunComplete((event.item.body ?? "").trim());
+			}
+		}
+	};
+	if (typeof cognitive.generateTextStream === "function") {
+		const parser = new require_dual_modes.StreamingMessageParser();
+		const fence = new LeadingFenceFilter();
+		const streamController = createJoinedAbortController([controller.signal]);
+		const requestedAt = Date.now();
+		const stream = cognitive.generateTextStream({
+			...input,
+			...ctx.maxTimeToFirstToken ? { options: {
+				...input.options,
+				maxTimeToFirstToken: ctx.maxTimeToFirstToken
+			} } : {}
+		}, { 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 = "";
+		while (true) {
+			var _chunk$value, _chunk$value2;
+			let chunk;
+			try {
+				chunk = await nextChunk();
+			} catch (thrown) {
+				throw new require_errors.CognitiveError(`LLM generation failed: ${require_utils.getErrorMessage(thrown)}`);
+			}
+			if (chunk.done) break;
+			if ((_chunk$value = chunk.value) === null || _chunk$value === void 0 ? void 0 : _chunk$value.metadata) responseMetadata = chunk.value.metadata;
+			const delta = (_chunk$value2 = chunk.value) === null || _chunk$value2 === void 0 ? void 0 : _chunk$value2.output;
+			if (!delta) continue;
+			timeToLastToken = Date.now() - requestedAt;
+			timeToFirstToken ??= timeToLastToken;
+			raw += delta;
+			await dispatchSends(parser.push(fence.push(delta)));
+		}
+		if (!responseMetadata) throw new require_errors.CognitiveError("LLM streaming completed without metadata");
+		const remaining = fence.flush();
+		if (remaining) await dispatchSends(parser.push(remaining));
+		await dispatchSends(parser.finish());
+		assistantResponse = require_dual_modes.toParsedAssistantResponse(parser.items, raw);
+	} else {
+		const response = await cognitive.generateText(input, { signal: controller.signal }).catch((thrown) => {
+			throw new require_errors.CognitiveError(`LLM generation failed: ${require_utils.getErrorMessage(thrown)}`);
+		});
+		if (!response.output) throw new require_errors.CognitiveError("LLM did not return any text output");
+		responseMetadata = response.metadata;
+		raw = response.output;
+		assistantResponse = ctx.version.parseAssistantResponse(raw);
+		for (const send of assistantResponse.sends) await (onSend === null || onSend === void 0 ? void 0 : onSend(send));
+	}
+	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,
+		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: model.id,
+		code: iteration.code ?? ""
+	});
+};
+//#endregion
+//#region src/runtime/interpret-result.ts
+const interpretVMResult = async ({ iteration, result, controller, startedAt, onExit }) => {
+	if (result.error && result.error instanceof require_errors.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 require_errors.CodeExecutionError) {
+		iteration.end({
+			type: "execution_error",
+			execution_error: {
+				message: result.error.message,
+				stack: require_stack_traces.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: require_stack_traces.cleanStackTrace(result.error.stack ?? "No stack trace available")
+			}
+		});
+		return;
+	}
+	if (result.signal instanceof require_errors.ThinkSignal) {
+		iteration.end({
+			type: "thinking_requested",
+			thinking_requested: {
+				variables: result.signal.context,
+				reason: result.signal.reason,
+				metadata: result.signal.metadata
+			}
+		});
+		return;
+	}
+	if (result.signal instanceof require_errors.SnapshotSignal) {
+		iteration.end({
+			type: "callback_requested",
+			callback_requested: { signal: result.signal }
+		});
+		return;
+	}
+	const returnValue = result.return_value;
+	const codeRequestsInspection = require_vm.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) => require_custom_client.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) {
+		iteration.end({
+			type: "exit_error",
+			exit_error: {
+				exit: next.name,
+				message: parsedExit.error,
+				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}: ${require_utils.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 = (0, ms.default)("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_${(0, ulid.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 require_errors.SnapshotSignal) {
+				err.toolCall = {
+					name: tool.name,
+					inputSchema: tool.input,
+					outputSchema: tool.output,
+					input: originalInput
+				};
+				err.message = require_errors.Signals.serializeError(err);
+			}
+			if (err instanceof require_errors.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 }, 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 = { ...require_utils.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 ?? _bpinternal_zui.z.any();
+			Object.defineProperty(instance, name, {
+				enumerable: true,
+				configurable: true,
+				get() {
+					return internalValues[name];
+				},
+				set(value) {
+					if (require_dual_modes.isEqual(value, internalValues[name])) return;
+					if (!writable) throw new require_errors.AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`);
+					const parsed = schema.safeParse(value);
+					if (!parsed.success) throw new require_errors.AssignmentError(`Invalid value for Object property ${obj.name}.${name}: ${require_utils.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 require_utils.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;
+	const controller = createJoinedAbortController([props.signal]);
+	const { onIterationStart, onIterationEnd, onTrace, onExit, onBeforeExecution, onAfterTool, onBeforeTool } = props;
+	const client = props.client ?? new _botpress_client.Client();
+	const cognitive = _botpress_cognitive.Cognitive.isCognitiveClient(client) || require_custom_client._CustomModelClient.isCustomClient(client) ? client : new _botpress_cognitive.Cognitive({ client });
+	const ctx = new require_custom_client.Context({
+		chat: props.chat,
+		instructions: props.instructions,
+		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,
+		transcriptionModel: (_props$options5 = props.options) === null || _props$options5 === void 0 ? void 0 : _props$options5.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 require_custom_client.ErrorExecutionResult(ctx, new require_errors.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 require_custom_client.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 require_custom_client.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 require_errors.ThinkSignal ? {
+				type: "thinking_requested",
+				thinking_requested: {
+					variables: err.context,
+					reason: err.reason
+				}
+			} : {
+				type: "execution_error",
+				execution_error: {
+					message: `Error in onIterationStart hook: ${require_utils.getErrorMessage(err)}`,
+					stack: require_stack_traces.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 require_errors.CognitiveError)) {
+			await finalizeIteration({
+				iteration,
+				controller,
+				onIterationEnd,
+				status: iteration.status.type === "pending" ? {
+					type: "execution_error",
+					execution_error: {
+						message: "An unexpected error occurred: " + require_utils.getErrorMessage(err),
+						stack: require_stack_traces.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 require_custom_client.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 require_custom_client.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 require_custom_client.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 require_custom_client.PartialExecutionResult(ctx, iteration.status.callback_requested.signal, require_custom_client.Snapshot.fromSignal(iteration.status.callback_requested.signal))
+	};
+	if (iteration.status.type === "aborted") return {
+		type: "return",
+		result: new require_custom_client.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 require_custom_client.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 require_vm.runAsyncFunction(vmContext, code, iteration.traces, controller.signal, ctx.timeout).catch((err) => {
+			return {
+				success: false,
+				error: err instanceof Error ? err : new Error(require_utils.getErrorMessage(err)),
+				lines_executed: [],
+				traces: [],
+				variables: {}
+			};
+		});
+	};
+	const canExecuteEarly = typeof onBeforeExecution !== "function";
+	let earlyExecution;
+	await generateCode({
+		iteration,
+		ctx,
+		cognitive,
+		controller,
+		metadata,
+		onRunStart: () => require_vm.warmupVM(),
+		onRunComplete: canExecuteEarly ? (code) => {
+			if (!code.length || controller.signal.aborted || earlyExecution) return;
+			iteration.code = code;
+			earlyExecution = {
+				code,
+				started_at: Date.now(),
+				promise: runCode(code)
+			};
+		} : void 0,
+		onSend: async (send) => {
+			if (!ctx.chat) return;
+			const sendStartedAt = Date.now();
+			const component = require_jsx.createJsxComponent({
+				type: send.name,
+				props: send.props,
+				children: send.body ? [send.body] : []
+			});
+			try {
+				await ctx.chat.handler(component);
+			} catch (err) {
+				throw new Error(`Error while sending message (■send=${send.name}): ${require_utils.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 (earlyExecution) iteration.code = earlyExecution.code;
+	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 require_errors.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: ${require_utils.getErrorMessage(err)}`,
+				stack: require_stack_traces.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$sends;
+		if (iteration.next) {
+			await applyNextExit({
+				iteration,
+				controller,
+				onExit
+			});
+			return;
+		}
+		if (ctx.chat && ((_iteration$sends = iteration.sends) === null || _iteration$sends === void 0 ? void 0 : _iteration$sends.length)) {
+			iteration.next = {
+				name: "listen",
+				props: {}
+			};
+			await applyNextExit({
+				iteration,
+				controller,
+				onExit
+			});
+			return;
+		}
+		iteration.end({
+			type: "invalid_code_error",
+			invalid_code_error: { message: "The response did not include a ■run block or a ■next exit. Reply using ■ blocks and end your response with ■run or ■next=<exit>." }
+		});
+		return;
+	}
+	const startedAt = (earlyExecution === null || earlyExecution === void 0 ? void 0 : earlyExecution.started_at) ?? Date.now();
+	const result = earlyExecution ? await earlyExecution.promise : await runCode(iteration.code ?? "");
+	await interpretVMResult({
+		iteration,
+		result,
+		controller,
+		startedAt,
+		onExit
+	});
+};
+//#endregion
+exports.executeContext = executeContext;