llmz 0.9.0 → 0.9.1

package/dist/index.workerd.js

@@ -52,7 +52,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 //#region package.json
-var version = "0.9.0", quoteExample, quotePartialExample, exampleBoundaryInstructions, quoteResponseExample;
+var version = "0.9.1", quoteExample, quotePartialExample, exampleBoundaryInstructions, quoteResponseExample;
 var init_example_format = __esmMin((() => {
 	quoteExample = (output) => `"""\n${output}\n"""`;
 	quotePartialExample = (output) => quoteExample(`(...)\n${output}\n(...)`);
@@ -1047,82 +1047,44 @@ var init_track_tool_calls = __esmMin((() => {
 }));
 //#endregion
 //#region src/compiler/plugins/variable-extraction.ts
-/**
-* Tracks user variables so the VM can read their values between iterations:
-* - after each variable declaration: `__var__("a", () => eval("a"));`
-* - at the top of function bodies, for their parameters
-*
-* The `eval` indirection captures the variable lazily in its own scope.
-*/
+function declaredNames(id) {
+	if (!id) return [];
+	if (id.type === "Identifier") return [id.name];
+	if (id.type === "RestElement") return declaredNames(id.argument);
+	if (id.type === "AssignmentPattern") return declaredNames(id.left);
+	if (id.type === "ArrayPattern") return id.elements.flatMap(declaredNames);
+	if (id.type === "ObjectPattern") return id.properties.flatMap((prop) => declaredNames(prop.type === "RestElement" ? prop.argument : prop.value));
+	return [];
+}
+/** Retain getters only for bindings visible between iterations, never local shadows. */
 function applyVariableTracking(ctx, variables) {
-	const trackerFor = (name) => {
-		if (name.startsWith("__")) return null;
-		variables.add(name);
-		return `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`;
-	};
-	const track = (names) => names.map(trackerFor).filter((t) => !!t).join("");
-	const declaredNames = (id) => {
-		if (id.type === "Identifier") return [id.name];
-		if (id.type === "ObjectPattern") {
-			const names = [];
-			for (const prop of id.properties) {
-				if (prop.type !== "Property") continue;
-				if (prop.value.type === "Identifier") names.push(prop.value.name);
-				else if (prop.value.type === "ObjectPattern") names.push(...declaredNames(prop.value));
-				else if (prop.value.type === "AssignmentPattern" && prop.value.left.type === "Identifier") names.push(prop.value.left.name);
-			}
-			return names;
-		}
-		if (id.type === "ArrayPattern") {
-			const names = [];
-			for (const element of id.elements) {
-				if (!element) continue;
-				if (element.type === "Identifier") names.push(element.name);
-				else if (element.type === "RestElement" && element.argument.type === "Identifier") names.push(element.argument.name);
-				else if (element.type === "AssignmentPattern" && element.left.type === "Identifier") names.push(element.left.name);
-			}
-			return names;
-		}
-		return [];
-	};
-	const paramNames = (params) => {
-		const names = [];
-		for (const param of params) if (param.type === "Identifier") names.push(param.name);
-		else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") names.push(param.left.name);
-		else if (param.type === "ObjectPattern") {
-			for (const prop of param.properties) if (prop.type === "Property" && prop.value.type === "Identifier") names.push(prop.value.name);
-		} else if (param.type === "ArrayPattern") {
-			for (const element of param.elements) if (element?.type === "Identifier") names.push(element.name);
-		}
-		return names;
-	};
-	walk$1(ctx.ast, (node, parent) => {
-		if (node.type === "VariableDeclaration") {
-			if (parent && (parent.type === "ForStatement" || parent.type === "ForInStatement" || parent.type === "ForOfStatement")) return;
-			const trackers = track(node.declarations.flatMap((d) => declaredNames(d.id)));
-			if (trackers) {
-				const semi = ctx.code[node.end - 1] === ";" ? "" : ";";
-				ctx.ms.appendRight(node.end, `${semi}${trackers}`);
-			}
-			return;
-		}
-		if (node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") {
-			const trackers = track(paramNames(node.params));
-			if (!trackers) return;
-			const body = node.body;
-			if (body.type === "BlockStatement") ctx.ms.appendRight(body.start + 1, trackers);
-			else {
-				const expressions = trackers.slice(0, -1).replaceAll(";", ",");
-				ctx.ms.prependLeft(body.start, `(${expressions}, (`);
-				ctx.ms.appendRight(body.end, "))");
-			}
+	const root = ctx.ast.body.find((node) => node.type === "FunctionDeclaration" && node.id?.name === "__fn__")?.body ?? ctx.ast;
+	const varBindings = /* @__PURE__ */ new Set();
+	const track = (names) => names.map((name) => `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`).join("");
+	walk$1(root, (node, parent, ancestors) => {
+		if (node.type !== "VariableDeclaration" || ancestors.some((ancestor) => FUNCTION_TYPES$1.has(ancestor.type) || ancestor.type === "StaticBlock")) return;
+		if (node.kind !== "var" && parent !== root) return;
+		const names = node.declarations.flatMap((declaration) => declaredNames(declaration.id)).filter((name) => !name.startsWith("__"));
+		for (const name of names) variables.add(name);
+		if (node.kind === "var" && parent !== root) for (const name of names) varBindings.add(name);
+		else if (node.declarations.length > 1) ctx.ms.appendLeft(node.start, track(names));
+		else {
+			const semi = ctx.code[node.end - 1] === ";" ? "" : ";";
+			ctx.ms.appendRight(node.end, semi + track(names));
 		}
 	});
+	const entry = root.body.find((node) => !node.directive);
+	if (entry && varBindings.size) ctx.ms.appendLeft(entry.start, track([...varBindings]));
 }
-var VariableTrackingFnIdentifier;
+var VariableTrackingFnIdentifier, FUNCTION_TYPES$1;
 var init_variable_extraction = __esmMin((() => {
 	init_ast();
 	VariableTrackingFnIdentifier = "__var__";
+	FUNCTION_TYPES$1 = /* @__PURE__ */ new Set([
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"ArrowFunctionExpression"
+	]);
 }));
 //#endregion
 //#region src/compiler/compiler.ts
@@ -9402,6 +9364,8 @@ var init_tool = __esmMin((() => {
 	init_utils$1();
 	Tool = class Tool {
 		_staticInputValues;
+		_inputSchema;
+		_outputSchema;
 		name;
 		aliases = [];
 		description;
@@ -9472,23 +9436,14 @@ var init_tool = __esmMin((() => {
 		* @internal
 		*/
 		get zInput() {
-			let input;
-			if (this.input) try {
-				input = transforms.fromJSONSchema(this.input);
-			} catch {
-				input = transforms.fromJSONSchemaLegacy(this.input);
-			}
-			else input = z.any();
-			if (!isEmpty(this._staticInputValues)) {
-				if (z.is.zuiObject(input)) {
-					const inputExtensions = convertObjectToZuiLiterals(this._staticInputValues);
-					input = input.extend(inputExtensions);
-				} else if (z.is.zuiArray(input)) {
-					const inputExtensions = convertObjectToZuiLiterals(this._staticInputValues);
-					input = z.array(input.element.extend(inputExtensions));
-				} else input = convertObjectToZuiLiterals(this._staticInputValues);
-			}
-			return input;
+			const input = this._inputSchema ?? (this.input ? fromJSONSchemaCompat(this.input) : z.any());
+			if (isEmpty(this._staticInputValues)) return input;
+			const shape = this.input ? fromJSONSchemaCompat(this.input) : z.any();
+			let overrides;
+			if (z.is.zuiObject(shape)) overrides = z.object(convertObjectToZuiLiterals(this._staticInputValues)).passthrough();
+			else if (z.is.zuiArray(shape)) overrides = z.array(z.object(convertObjectToZuiLiterals(this._staticInputValues)).passthrough());
+			else overrides = convertObjectToZuiLiterals(this._staticInputValues);
+			return overrides.pipe(input);
 		}
 		/**
 		* Gets the output schema for validation.
@@ -9584,18 +9539,8 @@ var init_tool = __esmMin((() => {
 		*/
 		clone(props = {}) {
 			try {
-				let zInput;
-				if (this.input) try {
-					zInput = transforms.fromJSONSchema(this.input);
-				} catch {
-					zInput = transforms.fromJSONSchemaLegacy(this.input);
-				}
-				let zOutput;
-				if (this.output) try {
-					zOutput = transforms.fromJSONSchema(this.output);
-				} catch {
-					zOutput = transforms.fromJSONSchemaLegacy(this.output);
-				}
+				const zInput = this._inputSchema ?? (this.input ? fromJSONSchemaCompat(this.input) : void 0);
+				const zOutput = this._outputSchema ?? (this.output ? fromJSONSchemaCompat(this.output) : void 0);
 				return new Tool({
 					name: props.name ?? this.name,
 					aliases: props.aliases ?? [...this.aliases],
@@ -9618,7 +9563,7 @@ var init_tool = __esmMin((() => {
 		* @param props.name - Unique tool name (must be valid TypeScript identifier)
 		* @param props.description - Human-readable description for the LLM
 		* @param props.input - Zui/Zod schema for input validation (optional)
-		* @param props.output - Zui/Zod schema for output validation (optional)
+		* @param props.output - Zui/Zod schema describing output (optional)
 		* @param props.handler - Async function that implements the tool logic
 		* @param props.aliases - Alternative names for the tool (optional)
 		* @param props.metadata - Additional metadata for the tool (optional)
@@ -9695,21 +9640,25 @@ var init_tool = __esmMin((() => {
 			if (props.aliases !== void 0 && !Array.isArray(props.aliases)) throw new Error(`Invalid aliases for tool ${props.name}. Expected an array, but got type "${typeof props.aliases}"`);
 			if (props.aliases && props.aliases.some((alias) => !isValidIdentifier(alias))) throw new Error(`Invalid aliases for tool ${props.name}. Expected an array of valid identifiers.`);
 			if (typeof props.input !== "undefined") {
-				if (isZuiSchema(props.input)) try {
-					this.input = transforms.toJSONSchema(props.input);
-				} catch {
-					this.input = transforms.toJSONSchemaLegacy(props.input);
-				}
-				else if (isJsonSchema(props.input)) this.input = props.input;
+				if (isZuiSchema(props.input)) {
+					this._inputSchema = props.input;
+					try {
+						this.input = transforms.toJSONSchema(props.input);
+					} catch {
+						this.input = transforms.toJSONSchemaLegacy(props.input);
+					}
+				} else if (isJsonSchema(props.input)) this.input = props.input;
 				else throw new Error(`Invalid input schema for tool ${props.name}. Expected a ZodType or JSONSchema, but got type "${typeof props.input}"`);
 			}
 			if (typeof props.output !== "undefined") {
-				if (isZuiSchema(props.output)) try {
-					this.output = transforms.toJSONSchema(props.output);
-				} catch {
-					this.output = transforms.toJSONSchemaLegacy(props.output);
-				}
-				else if (isJsonSchema(props.output)) this.output = props.output;
+				if (isZuiSchema(props.output)) {
+					this._outputSchema = props.output;
+					try {
+						this.output = transforms.toJSONSchema(props.output);
+					} catch {
+						this.output = transforms.toJSONSchemaLegacy(props.output);
+					}
+				} else if (isJsonSchema(props.output)) this.output = props.output;
 				else throw new Error(`Invalid output schema for tool ${props.name}. Expected a ZodType or JSONSchema, but got type "${typeof props.output}"`);
 			}
 			this.name = props.name;
@@ -9740,7 +9689,7 @@ var init_tool = __esmMin((() => {
 		/**
 		* Executes the tool with the given input and context.
 		*
-		* This method handles input validation, retry logic, output validation, and error handling.
+		* This method handles input validation, retry logic, and error handling.
 		* It's called internally by the LLMz execution engine when generated code calls the tool.
 		*
 		* @param input - Input data to pass to the tool handler
@@ -9762,17 +9711,16 @@ var init_tool = __esmMin((() => {
 		* @internal This method is primarily used internally by the LLMz execution engine
 		*/
 		async execute(rawInput, ctx, chat) {
-			const input = this.zInput._def.typeName === "ZodObject" ? rawInput ?? {} : rawInput;
-			const pInput = this.zInput.safeParse(input);
+			const shape = this.input ? fromJSONSchemaCompat(this.input) : z.any();
+			const input = z.is.zuiObject(shape) ? rawInput ?? {} : rawInput;
+			const pInput = await this.zInput.safeParseAsync(input);
 			if (!pInput.success) throw new Error(`Tool "${this.name}" received invalid input: ${pInput.error.message}`);
 			let attempt = 0;
 			let yieldedCount = 0;
 			while (attempt < this.MAX_RETRIES) try {
-				const result = await this._executeHandler(pInput.data, ctx, chat, yieldedCount, (n) => {
+				return await this._executeHandler(pInput.data, ctx, chat, yieldedCount, (n) => {
 					yieldedCount = n;
 				});
-				const pOutput = this.zOutput.safeParse(result);
-				return pOutput.success ? pOutput.data : result;
 			} catch (err) {
 				if (!await this.retry?.({
 					input: pInput.data,
@@ -11528,7 +11476,7 @@ function printLimitedJson(obj, maxDepth, maxLength, maxKeys) {
 			}
 		}
 		if (typeof currentObj !== "object" || currentObj === null) {
-			const value = JSON.stringify(currentObj);
+			const value = stringify(currentObj);
 			currentLength += getTokenizer().count(value);
 			return value;
 		}
@@ -11600,10 +11548,10 @@ function previewValue(value, length = LONG_TEXT_LENGTH) {
 	};
 	const previewObj = (obj) => {
 		const mapped = mapKeys(obj, (_value, key) => previewStr(key));
-		return JSON.stringify(mapped);
+		return stringify(mapped);
 	};
 	if (typeof value === "string") return "<string> " + previewStr(value);
-	if (typeof value === "object" && Array.isArray(value)) return "<array> " + previewStr(JSON.stringify(value));
+	if (typeof value === "object" && Array.isArray(value)) return "<array> " + previewStr(stringify(value));
 	if (typeof value === "object" && value instanceof Date) return "<date> " + value.toISOString();
 	if (typeof value === "object" && value instanceof RegExp) return "<regexp> " + value.toString();
 	if (typeof value === "object") return "<object> " + previewObj(value);
@@ -11643,15 +11591,15 @@ function previewArray(arr, maxStringLength = LONG_TEXT_LENGTH) {
 	lines.push("// Analysis Summary");
 	lines.push(SUBTITLE_LN);
 	const typesCount = countBy(arr, (item) => extractType(item, false));
-	const ordered = orderBy(arr.filter((item) => !isNil(item) && JSON.stringify(item).length < 100), (item) => JSON.stringify(item), "asc");
+	const ordered = orderBy(arr.filter((item) => !isNil(item) && stringify(item).length < 100), (item) => stringify(item), "asc");
 	const minValues = ordered.slice(0, 3).map((item) => previewValue(item, 10));
 	const maxValues = ordered.slice(-3).map((item) => previewValue(item, 10));
 	const uniqueItems = uniqWith(arr, isEqual);
 	const nullValues = filter(arr, isNil).length;
-	const memoryUsage = bytes(JSON.stringify(arr).length);
+	const memoryUsage = bytes(stringify(arr).length);
 	lines.push(`Total Items:     ${arr.length}`);
 	lines.push(`Unique Items:    ${uniqueItems.length}`);
-	lines.push(`Types:           ${JSON.stringify(typesCount)}`);
+	lines.push(`Types:           ${stringify(typesCount)}`);
 	lines.push(`Minimum Values:  [${minValues.join(", ")}]`);
 	lines.push(`Maximum Values:  [${maxValues.join(", ")}]`);
 	lines.push(`Memory Usage:    ${memoryUsage}`);
@@ -11674,7 +11622,7 @@ function previewObject(obj, options) {
 		const keys = Object.keys(obj);
 		const uniqueEntries = uniq(Object.values(obj));
 		const nilValues = filter(entries, ([, value]) => isNil(value)).length;
-		const memoryUsage = bytes(JSON.stringify(obj).length);
+		const memoryUsage = bytes(stringify(obj).length);
 		lines.push(`Total Entries:   ${NUMBER_LOCALE.format(entries.length)}`);
 		lines.push(`Keys:            ${previewValue(keys)}`);
 		lines.push(`Popular Types:   ${previewValue(typesCount)}`);
@@ -11724,7 +11672,7 @@ function previewLongText(text, length = LONG_TEXT_LENGTH) {
 	lines.push(`Most Common Words:    ${mostCommonWords}`);
 	return lines.join("\n").replace(/\n{2,}/g, SECTION_SEP);
 }
-var SUBTITLE_LN, SECTION_SEP, NUMBER_LOCALE, LONG_TEXT_LENGTH, DEFAULT_OPTIONS, inspect;
+var SUBTITLE_LN, SECTION_SEP, NUMBER_LOCALE, LONG_TEXT_LENGTH, DEFAULT_OPTIONS, stringify, inspect;
 var init_inspect = __esmMin((() => {
 	init_lodash();
 	init_utils$1();
@@ -11733,6 +11681,7 @@ var init_inspect = __esmMin((() => {
 	NUMBER_LOCALE = new Intl.NumberFormat("en-US");
 	LONG_TEXT_LENGTH = 4096;
 	DEFAULT_OPTIONS = { tokens: 1e5 };
+	stringify = (value) => JSON.stringify(value, (_key, item) => typeof item === "bigint" ? item.toString() + "n" : item);
 	inspect = (value, name, options = DEFAULT_OPTIONS) => {
 		options ??= DEFAULT_OPTIONS;
 		options.tokens ??= DEFAULT_OPTIONS.tokens;
@@ -11741,7 +11690,7 @@ var init_inspect = __esmMin((() => {
 			let header = "";
 			if (name) header = `// const ${name}: ${genericType}\n`;
 			if (genericType === "Array") return header + previewArray(value, options.maxStringLength);
-			else if (genericType === "error") return header + previewError(value);
+			else if (genericType === "error") return getTokenizer().truncate(header + previewError(value), options.tokens);
 			else if (genericType === "object") return header + previewObject(value, options);
 			else if (genericType === "boolean") return header + previewValue(value);
 			else if (typeof value === "string") {
@@ -11750,7 +11699,7 @@ var init_inspect = __esmMin((() => {
 			}
 			return header + previewValue(value);
 		} catch (err) {
-			return `Error: ${err?.message ?? "Unknown Error"}`;
+			return getTokenizer().truncate(`Error: ${err?.message ?? "Unknown Error"}`, options.tokens);
 		}
 	};
 }));
@@ -12394,9 +12343,9 @@ function truncateWrappedContent({ messages, tokenLimit, throwOnFailure = true })
 	* After                       { content: 'content', tokens: 10, truncatable: false }
 	*/
 	const parts = [];
-	for (const msg of messages) {
+	const contents = messages.flatMap((message) => typeof message.content === "string" ? [message.content] : (message.content ?? []).flatMap((part) => part.type === "text" ? [part.text ?? ""] : []));
+	for (const content of contents) {
 		const current = [];
-		const content = typeof msg.content === "string" ? msg.content : "";
 		let match;
 		const parser = new _MessageContentParser();
 		while ((match = parser.parse(content)) !== null) {
@@ -12454,13 +12403,15 @@ function truncateWrappedContent({ messages, tokenLimit, throwOnFailure = true })
 		biggest.tokens -= toRemove;
 		currentCount -= toRemove;
 	}
-	return messages.map((msg, i) => {
-		const p = parts[i];
-		return {
-			...msg,
-			content: typeof msg.content === "string" ? _renderRemainingWrappers(p.map((part) => part.content).join("")) : msg.content
-		};
-	});
+	let textIndex = 0;
+	const renderText = () => _renderRemainingWrappers(parts[textIndex++].map((part) => part.content).join(""));
+	return messages.map((message) => ({
+		...message,
+		content: typeof message.content === "string" ? renderText() : message.content?.map((part) => part.type === "text" ? {
+			...part,
+			text: renderText()
+		} : part) ?? message.content
+	}));
 }
 var DEFAULT_REMOVE_CHUNK, WRAP_OPEN_TAG_1, WRAP_OPEN_TAG_2, WRAP_CLOSE_TAG, REGEXP, DEFAULT_TRUNCATE_OPTIONS, _MessageContentParser, _createRegex, _renderRemainingWrappers, stripTruncationTags, _countTotalTokens, _getTwoBiggestTruncables;
 var init_truncator = __esmMin((() => {
@@ -17691,7 +17642,7 @@ function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue) {
 	if (descriptor.set) {
 		const setterBridge = vm.newFunction(`set_${propName}`, (valueHandle) => {
 			try {
-				const jsValue = vm.dump(valueHandle);
+				const jsValue = readVmValue(vm, valueHandle, true);
 				if (prop) context[key][prop] = jsValue;
 				else context[key] = jsValue;
 				return vm.undefined;
@@ -17716,27 +17667,84 @@ function bridgeGetterSetter(vm, key, prop, descriptor, context, toVmValue) {
 	if ("error" in result) result.error?.dispose();
 	else result.value.dispose();
 }
-function setupVariableTrackingBridge(vm, variables) {
-	const varTrackFnHandle = vm.newFunction(Identifiers.VariableTrackingFnIdentifier, (nameHandle, getterHandle) => {
+function installValueReader(vm) {
+	vm.evalCode(`
+    globalThis.__llmz_read_value = function encode(value, strict, seen = new Set()) {
+      if (value === undefined) return ['undefined'];
+      if (typeof value === 'number') {
+        if (strict && !Number.isFinite(value)) throw new Error('Non-finite numbers cannot be assigned to host properties');
+        return ['number', Object.is(value, -0) ? '-0' : String(value)];
+      }
+      if (value === null || typeof value === 'string' || typeof value === 'boolean') return ['value', value];
+      if (typeof value !== 'object') throw new Error('Unsupported VM value: ' + typeof value);
+      if (seen.has(value)) throw new Error('Cyclic VM values cannot be transferred');
+      if (value instanceof Date) return ['value', value.toJSON()];
+      seen.add(value);
+      try {
+        if (Array.isArray(value)) return ['array', Array.from(value, item => encode(item, strict, seen))];
+        return ['object', Object.entries(value).map(([key, item]) => [key, encode(item, strict, seen)])];
+      } finally {
+        seen.delete(value);
+      }
+    };
+  `).unwrap().dispose();
+}
+function readVmValue(vm, handle, strict = false) {
+	const decode = ([type, value]) => {
+		if (type === "undefined") return void 0;
+		if (type === "number") return Number(value);
+		if (type === "array") return value.map(decode);
+		if (type === "object") return Object.fromEntries(value.map(([key, item]) => [key, decode(item)]));
+		return value;
+	};
+	const encoder = vm.getProp(vm.global, "__llmz_read_value");
+	try {
+		const result = vm.callFunction(encoder, vm.undefined, handle, strict ? vm.true : vm.false);
+		if (result.error) {
+			const error = vm.dump(result.error);
+			result.error.dispose();
+			if (strict) throw new Error(error.message);
+			const copy = handle.dup();
+			try {
+				return vm.dump(copy);
+			} finally {
+				if (copy.alive) copy.dispose();
+			}
+		}
+		try {
+			return decode(vm.dump(result.value));
+		} finally {
+			result.value.dispose();
+		}
+	} finally {
+		encoder.dispose();
+	}
+}
+function setupVariableTrackingBridge(vm, variables, getters) {
+	const tracker = vm.newFunction(Identifiers.VariableTrackingFnIdentifier, (nameHandle, getterHandle) => {
 		const name = vm.getString(nameHandle);
 		if (NO_TRACKING.includes(name)) return;
-		try {
-			const valueResult = vm.callFunction(getterHandle, vm.undefined);
-			if ("error" in valueResult) {
-				variables[name] = "[[non-primitive]]";
-				valueResult.error?.dispose();
-				return;
+		getters.get(name)?.dispose();
+		const getter = getterHandle.dup();
+		getters.set(name, getter);
+		variables[name] = () => {
+			const result = vm.callFunction(getter, vm.undefined);
+			if (result.error) {
+				result.error.dispose();
+				return "[[non-primitive]]";
 			}
-			const value = vm.dump(valueResult.value);
-			valueResult.value.dispose();
-			if (typeof value === "function" || typeof value === "string" && value.includes("=>")) variables[name] = "[[non-primitive]]";
-			else variables[name] = value;
-		} catch {
-			variables[name] = "[[non-primitive]]";
-		}
+			try {
+				if (vm.typeof(result.value) === "function") return "[[non-primitive]]";
+				return readVmValue(vm, result.value);
+			} catch {
+				return "[[non-primitive]]";
+			} finally {
+				result.value.dispose();
+			}
+		};
 	});
-	vm.setProp(vm.global, Identifiers.VariableTrackingFnIdentifier, varTrackFnHandle);
-	varTrackFnHandle.dispose();
+	vm.setProp(vm.global, Identifiers.VariableTrackingFnIdentifier, tracker);
+	tracker.dispose();
 }
 function buildScriptCode(transformedCode) {
 	return `
@@ -17793,6 +17801,22 @@ var init_quickjs = __esmMin((() => {
 			const trackedProperties = /* @__PURE__ */ new Set();
 			const referenceProperties = /* @__PURE__ */ new Set();
 			const pendingPromises = [];
+			const variableGetters = /* @__PURE__ */ new Map();
+			const objectConstructor = vm.getProp(vm.global, "Object");
+			const freezeFunction = vm.getProp(objectConstructor, "freeze");
+			objectConstructor.dispose();
+			const preserveFreeze = (value, handle) => {
+				if (Object.isFrozen(value)) {
+					const frozen = vm.callFunction(freezeFunction, vm.undefined, handle);
+					try {
+						frozen.unwrap().dispose();
+					} catch (error) {
+						handle.dispose();
+						throw error;
+					}
+				}
+				return handle;
+			};
 			const toVmValue = (value) => {
 				if (typeof value === "string") return vm.newString(value);
 				else if (typeof value === "number") return vm.newNumber(value);
@@ -17800,20 +17824,13 @@ var init_quickjs = __esmMin((() => {
 				else if (value === null) return vm.null;
 				else if (value === void 0) return vm.undefined;
 				else if (Array.isArray(value)) {
-					const items = value.map((item) => {
-						if (typeof item === "string") return JSON.stringify(item);
-						else if (typeof item === "number" || typeof item === "boolean") return String(item);
-						else if (item === null) return "null";
-						else if (item === void 0) return "undefined";
-						else if (typeof item === "object") return JSON.stringify(item);
-						return "undefined";
+					const array = vm.newArray();
+					value.forEach((item, index) => {
+						const handle = toVmValue(item);
+						vm.setProp(array, index, handle);
+						disposeIfNeeded(handle);
 					});
-					const result = vm.evalCode(`[${items.join(",")}]`);
-					if ("error" in result) {
-						result.error?.dispose();
-						return vm.undefined;
-					}
-					return result.value;
+					return preserveFreeze(value, array);
 				} else if (typeof value === "object") {
 					const obj = vm.newObject();
 					for (const [k, v] of Object.entries(value)) if (typeof v !== "function") {
@@ -17821,7 +17838,7 @@ var init_quickjs = __esmMin((() => {
 						vm.setProp(obj, k, propHandle);
 						disposeIfNeeded(propHandle);
 					}
-					return obj;
+					return preserveFreeze(value, obj);
 				}
 				return vm.undefined;
 			};
@@ -17852,8 +17869,9 @@ var init_quickjs = __esmMin((() => {
 				};
 			};
 			try {
+				installValueReader(vm);
 				bridgeContextToVM(context, vm, trackedProperties, referenceProperties, toVmValue, disposeIfNeeded, bridgeFunction);
-				setupVariableTrackingBridge(vm, variables);
+				setupVariableTrackingBridge(vm, variables, variableGetters);
 				const scriptCode = buildScriptCode(transformed.code);
 				const copyBackContextFromVM = () => {
 					for (const key of trackedProperties) {
@@ -17910,7 +17928,7 @@ var init_quickjs = __esmMin((() => {
 				let returnValue = void 0;
 				if (resultSet) {
 					const resultResult = vm.evalCode("globalThis.__llmz_result");
-					returnValue = vm.dump(resultResult.unwrap());
+					returnValue = readVmValue(vm, resultResult.unwrap());
 					resultResult.unwrap().dispose();
 				}
 				returnValue = Signals.maybeDeserializeError(returnValue);
@@ -17942,6 +17960,8 @@ var init_quickjs = __esmMin((() => {
 				})).catch(() => {});
 				return handleErrorQuickJS(err, code, consumer, traces, variables, lines_executed, userCodeStartLine, ctx.currentToolCall ?? state.currentToolCall);
 			} finally {
+				for (const getter of variableGetters.values()) getter.dispose();
+				freezeFunction.dispose();
 				try {
 					vm.dispose();
 				} catch {}
@@ -18058,21 +18078,10 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
 	});
 	context ??= {};
 	for (const name of Array.from(transformed.variables)) delete context[name];
-	let driver;
+	let driver = new NodeDriver();
 	if (useQuickJS()) try {
+		await loadQuickJSModule();
 		driver = new QuickJSDriver();
-		return await driver.execute({
-			transformed,
-			consumer,
-			context,
-			traces,
-			signal,
-			timeout,
-			code,
-			lines_executed,
-			variables,
-			currentToolCall: void 0
-		});
 	} catch (quickjsError) {
 		const variant = getQuickJSVariant();
 		const debugInfo = {
@@ -18098,7 +18107,6 @@ async function runAsyncFunction(context, code, traces = [], signal = null, timeo
 		console.warn("Error:", quickjsError?.message || quickjsError);
 		console.warn("Debug info:", JSON.stringify(debugInfo, null, 2));
 	}
-	driver = new NodeDriver();
 	return await driver.execute({
 		transformed,
 		consumer,
@@ -18146,19 +18154,21 @@ var init_generate = __esmMin((() => {
 	STREAM_INACTIVITY_TIMEOUT = 18e4;
 	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}`);
+		if (metadata.stopReason === "max_tokens" || metadata.stopReason === "content_filter" || metadata.stopReason === "other") throw new CognitiveError(`LLM generation did not complete: stopReason=${metadata.stopReason}`);
 	};
 	getModelOutputLimit = (inputLength) => clamp(RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength, RESPONSE_LENGTH_BUFFER.MIN_TOKENS, RESPONSE_LENGTH_BUFFER.MAX_TOKENS);
 	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) => {
+		controller.signal.throwIfAborted();
+		const modelRefs = Array.isArray(iteration.model) ? iteration.model : [iteration.model];
+		const models = await Promise.all(modelRefs.map((modelRef) => 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);
+		})));
+		controller.signal.throwIfAborted();
+		const model = models[0];
+		const modelLimit = Math.min(...models.map((model) => model.input.maxTokens), ctx.maxTokens ?? Infinity);
+		const responseLengthBuffer = Math.min(getModelOutputLimit(modelLimit), Math.floor(modelLimit / 2));
 		if (iteration.tokens) iteration.tokens.limit = modelLimit;
 		let messages;
 		try {
@@ -18377,6 +18387,7 @@ var init_generate = __esmMin((() => {
 			const response = await cognitive.generateText(input, { signal: controller.signal }).catch((thrown) => {
 				throw new CognitiveError(`LLM generation failed: ${getErrorMessage(thrown)}`);
 			});
+			controller.signal.throwIfAborted();
 			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;
@@ -18590,8 +18601,10 @@ var init_utils = __esmMin((() => {
 //#endregion
 //#region src/runtime/tool-wrapper.ts
 function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook, controller }) {
-	const getToolInput = (input) => tool.zInput.safeParse(input).data ?? input;
+	const traceSchema = tool.input ? fromJSONSchemaCompat(tool.input) : void 0;
+	const getToolInput = (input) => traceSchema?.safeParse(input).data ?? input;
 	return async function(input) {
+		controller.signal.throwIfAborted();
 		const toolCallId = `tcall_${ulid()}`;
 		const originalInput = input;
 		let effectiveInput = input;
@@ -18667,6 +18680,7 @@ function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook
 				object,
 				toolCallId
 			});
+			controller.signal.throwIfAborted();
 			if (typeof beforeRes?.input !== "undefined") effectiveInput = beforeRes.input;
 			output = await tool.execute(effectiveInput, {
 				callId: toolCallId,
@@ -18683,9 +18697,16 @@ function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook
 			});
 			if (typeof afterRes?.output !== "undefined") output = afterRes.output;
 		} catch (err) {
-			if (!await handleSignals(err)) {
+			try {
+				if (!await handleSignals(err)) {
+					success = false;
+					error = err;
+					output = void 0;
+				}
+			} catch (hookError) {
 				success = false;
-				error = err;
+				error = hookError;
+				output = void 0;
 			}
 		} finally {
 			clearTimeout(alertSlowTool);
@@ -18699,6 +18720,7 @@ function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook
 var SLOW_TOOL_WARNING;
 var init_tool_wrapper = __esmMin((() => {
 	init_errors$1();
+	init_utils$1();
 	SLOW_TOOL_WARNING = ms("15s");
 }));
 //#endregion