llmz 0.9.0 → 1.0.2

package/dist/truncate-uomAMGPs.cjs

@@ -0,0 +1,102 @@
+const require_errors = require("./errors-C6ppQUZX.cjs");
+//#region src/truncate.ts
+const TRUNCATE_SIGNATURE = "llmz.truncate.v1";
+const DEFAULT_TOOL_RESULT_MAX_TOKENS = 2e3;
+/** Sets a display budget without truncating or changing the underlying value. */
+function truncate({ value, maxTokens, preserve = "top" }) {
+	if (!Number.isSafeInteger(maxTokens) || maxTokens < 0) throw new require_errors.InvalidConfigurationError("maxTokens must be a finite nonnegative integer");
+	if (preserve !== "top" && preserve !== "bottom" && preserve !== "both") throw new require_errors.InvalidConfigurationError("preserve must be \"top\", \"bottom\", or \"both\"");
+	return Object.freeze({
+		$$truncate: Object.freeze({
+			signature: TRUNCATE_SIGNATURE,
+			maxTokens,
+			preserve
+		}),
+		value
+	});
+}
+function ownValue(value, key) {
+	const descriptor = Object.getOwnPropertyDescriptor(value, key);
+	return descriptor && "value" in descriptor ? descriptor.value : void 0;
+}
+function isTruncated(value) {
+	if (!value || typeof value !== "object") return false;
+	const policy = ownValue(value, "$$truncate");
+	if (!policy || typeof policy !== "object" || !Object.hasOwn(value, "value")) return false;
+	const signature = ownValue(policy, "signature");
+	const maxTokens = ownValue(policy, "maxTokens");
+	const preserve = ownValue(policy, "preserve");
+	const valueDescriptor = Object.getOwnPropertyDescriptor(value, "value");
+	return signature === TRUNCATE_SIGNATURE && typeof maxTokens === "number" && Number.isSafeInteger(maxTokens) && maxTokens >= 0 && (preserve === "top" || preserve === "bottom" || preserve === "both") && !!valueDescriptor && "value" in valueDescriptor;
+}
+function isContainer(value) {
+	if (!value || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return Array.isArray(value) || prototype === Object.prototype || prototype === null;
+}
+function unwrapTruncated(value) {
+	let underlying = value;
+	const rootWrappers = /* @__PURE__ */ new WeakSet();
+	while (isTruncated(underlying)) {
+		if (rootWrappers.has(underlying)) throw new require_errors.InvalidConfigurationError("Circular truncation wrappers cannot be unwrapped");
+		rootWrappers.add(underlying);
+		underlying = underlying.value;
+	}
+	const visited = /* @__PURE__ */ new WeakSet();
+	function containsWrapper(current) {
+		if (isTruncated(current)) return true;
+		if (!isContainer(current) || visited.has(current)) return false;
+		visited.add(current);
+		for (const key of Reflect.ownKeys(current)) if (containsWrapper(ownValue(current, key))) return true;
+		return false;
+	}
+	if (!containsWrapper(underlying)) return underlying;
+	const copies = /* @__PURE__ */ new WeakMap();
+	const wrappers = /* @__PURE__ */ new WeakSet();
+	function unwrap(current) {
+		if (current && typeof current === "object" && copies.has(current)) return copies.get(current);
+		if (isTruncated(current)) {
+			if (wrappers.has(current)) throw new require_errors.InvalidConfigurationError("Circular truncation wrappers cannot be unwrapped");
+			wrappers.add(current);
+			const result = unwrap(current.value);
+			wrappers.delete(current);
+			copies.set(current, result);
+			return result;
+		}
+		if (!isContainer(current)) return current;
+		const copy = Array.isArray(current) ? new Array(current.length) : Object.create(Object.getPrototypeOf(current));
+		copies.set(current, copy);
+		for (const key of Reflect.ownKeys(current)) {
+			const descriptor = Object.getOwnPropertyDescriptor(current, key);
+			if ("value" in descriptor) descriptor.value = unwrap(descriptor.value);
+			Object.defineProperty(copy, key, descriptor);
+		}
+		return copy;
+	}
+	return unwrap(underlying);
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_TOOL_RESULT_MAX_TOKENS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_TOOL_RESULT_MAX_TOKENS;
+	}
+});
+Object.defineProperty(exports, "isTruncated", {
+	enumerable: true,
+	get: function() {
+		return isTruncated;
+	}
+});
+Object.defineProperty(exports, "truncate", {
+	enumerable: true,
+	get: function() {
+		return truncate;
+	}
+});
+Object.defineProperty(exports, "unwrapTruncated", {
+	enumerable: true,
+	get: function() {
+		return unwrapTruncated;
+	}
+});

package/dist/truncate.d.ts

@@ -0,0 +1,24 @@
+declare const TRUNCATE_SIGNATURE = "llmz.truncate.v1";
+export declare const DEFAULT_TOOL_RESULT_MAX_TOKENS = 2000;
+export type TruncatePreserve = 'top' | 'bottom' | 'both';
+export type TruncationPolicy = {
+    maxTokens: number;
+    preserve: TruncatePreserve;
+};
+export type Truncated<T> = {
+    readonly $$truncate: Readonly<TruncationPolicy & {
+        signature: typeof TRUNCATE_SIGNATURE;
+    }>;
+    readonly value: T;
+};
+/** Sets a display budget without truncating or changing the underlying value. */
+export declare function truncate<T>({ value, maxTokens, preserve, }: {
+    value: T;
+    maxTokens: number;
+    preserve?: TruncatePreserve;
+}): Truncated<T>;
+export declare function isTruncated(value: unknown): value is Truncated<unknown>;
+/** Removes display wrappers from plain data without changing the wrapped values. */
+export declare function unwrapTruncated<T>(value: Truncated<T>): T;
+export declare function unwrapTruncated<T>(value: T): T;
+export {};

package/dist/truncate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -12,6 +12,7 @@ export declare namespace Traces {
         success: true;
         tool_name: string;
         tool_call_id: string;
+        native_call_id?: string;
         object?: string;
         input: any;
         output: any;
@@ -20,6 +21,7 @@ export declare namespace Traces {
         success: false;
         tool_name: string;
         tool_call_id: string;
+        native_call_id?: string;
         object?: string;
         input: any;
         error: any;
@@ -33,6 +35,12 @@ export declare namespace Traces {
         duration: number;
     }>;
     type ThinkSignal = TraceTemplate<'think_signal', {
+        tool_name?: string;
+        tool_call_id?: string;
+        object?: string;
+        reason?: string;
+        context?: unknown;
+        metadata?: Record<string, unknown>;
         line: number;
     }>;
     type PropertyMutation = TraceTemplate<'property', {
@@ -62,18 +70,16 @@ export declare namespace Traces {
         toModel: string;
         reason: string;
     }>;
-    /**
-     * Emitted on streaming clients the moment the model starts writing a `■run`
-     * block — before the code is fully generated. Useful to show a
-     * "writing code..." indicator while waiting for `llm_call_success` (which
-     * carries the final code) and the subsequent execution.
-     */
-    type CodeGenerationStart = TraceTemplate<'code_generation_started', {}>;
     type AbortTrace = TraceTemplate<'abort_signal', {
         reason: string;
     }>;
-    type YieldTrace = TraceTemplate<'yield', {
+    /** A message send and its delivery outcome, used to avoid replaying completed effects. */
+    type MessageDelivery = TraceTemplate<'message_delivery', {
         value: any;
+        message_id?: string;
+        native_call_id?: string;
+        success?: boolean;
+        error?: string;
     }>;
     type InvalidCodeExceptionTrace = TraceTemplate<'invalid_code_exception', {
         message: string;
@@ -84,7 +90,7 @@ export declare namespace Traces {
         started_at: number;
         ended_at?: number;
     } & Content;
-    type Trace = Comment | Log | ToolCall | ToolSlow | PropertyMutation | YieldTrace | LLMCallStart | LLMCallSuccess | LLMCallRestart | CodeGenerationStart | ThinkSignal | CodeExecution | CodeExecutionException | InvalidCodeExceptionTrace | AbortTrace;
+    type Trace = Comment | Log | ToolCall | ToolSlow | PropertyMutation | MessageDelivery | LLMCallStart | LLMCallSuccess | LLMCallRestart | ThinkSignal | CodeExecution | CodeExecutionException | InvalidCodeExceptionTrace | AbortTrace;
 }
 export type Trace = Traces.Trace;
 export type VMExecutionResult = {
@@ -92,6 +98,15 @@ export type VMExecutionResult = {
     variables: {
         [k: string]: any;
     };
+    variableWrites?: {
+        name: string;
+        timestamp: number;
+        kind?: 'assignment' | 'mutation';
+    }[];
+    captureErrors?: {
+        name: string;
+        reason: string;
+    }[];
     signal?: VMSignal;
     error?: Error;
     lines_executed: [number, number][];
@@ -101,6 +116,15 @@ export type VMExecutionResult = {
     variables: {
         [k: string]: any;
     };
+    variableWrites?: {
+        name: string;
+        timestamp: number;
+        kind?: 'assignment' | 'mutation';
+    }[];
+    captureErrors?: {
+        name: string;
+        reason: string;
+    }[];
     signal?: VMSignal;
     error: Error;
     traces: Trace[];

package/dist/{typings-3lsqCbkn.cjs → typings-BA_XxAcY.cjs}

@@ -1,11 +1,10 @@
-const require_compiler = require("./compiler-C-OI9sim.cjs");
-const require_utils = require("./utils-3ESwP3yg.cjs");
-const require_errors = require("./errors-C962uJdS.cjs");
+const require_utils = require("./utils-CTlsXvdj.cjs");
+const require_errors = require("./errors-C6ppQUZX.cjs");
 let _bpinternal_zui = require("@bpinternal/zui");
 //#region src/typings-formatter.ts
 /**
 * A minimal, dependency-free formatter for the TypeScript typings generated by
-* llmz (typings.ts, objects.ts, hoist.ts). It supports only the small grammar
+* llmz (typings.ts, objects.ts). It supports only the small grammar
 * those generators emit — type expressions, `declare const` / `declare function`
 * declarations, `type` aliases and `export namespace` blocks — and produces
 * prettier-like output: 80 columns, 2-space indent, no semicolons in broken
@@ -427,7 +426,7 @@ function breakGroup(p, g, level, tailWidth = 0) {
 		});
 		return;
 	}
-	const separator = g.open === "(" || g.open === "[" ? "," : usedComma ? "," : null;
+	const separator = g.open === "(" || g.open === "[" || usedComma ? "," : null;
 	const trailingSeparator = g.open === "(" || g.open === "[";
 	p.atom({
 		kind: "open",
@@ -566,178 +565,42 @@ async function formatTypings(typings, options) {
 }
 //#endregion
 //#region src/typings.ts
-var typings_exports = /* @__PURE__ */ require_compiler.__exportAll({ getTypings: () => getTypings });
-const Primitives = [
-	"string",
-	"number",
-	"boolean",
-	"unknown",
-	"void",
-	"any",
-	"null",
-	"undefined",
-	"never",
-	"bigint",
-	"symbol",
-	"object"
-];
-const LARGE_DECLARATION_LINES = 5;
-const isPrimitive = (type) => Primitives.includes(type);
-const isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
-const stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
-var KeyValue = class {
-	key;
-	value;
-	constructor(key, value) {
-		this.key = key;
-		this.value = value;
-	}
-};
-var FnParameters = class {
-	schema;
-	constructor(schema) {
-		this.schema = schema;
-	}
-};
-var FnReturn = class {
-	schema;
-	constructor(schema) {
-		this.schema = schema;
-	}
-};
-var Declaration = class {
-	schema;
-	identifier;
-	constructor(schema, identifier) {
-		this.schema = schema;
-		this.identifier = identifier;
+var typings_exports = /* @__PURE__ */ require_utils.__exportAll({
+	getTypings: () => getTypings,
+	schemaToTypeScript: () => schemaToTypeScript
+});
+/** One schema renderer for API inputs, results, and memory properties. */
+function schemaToTypeScript(schema) {
+	if (_bpinternal_zui.z.is.zuiDefault(schema)) return schemaToTypeScript(schema._def.innerType);
+	const options = { treatDefaultAsOptional: true };
+	try {
+		return _bpinternal_zui.transforms.toTypescriptType(schema, options);
+	} catch {
+		const normalized = require_utils.fromJSONSchemaCompat(_bpinternal_zui.transforms.toJSONSchemaLegacy(schema));
+		return _bpinternal_zui.transforms.toTypescriptType(normalized, options);
 	}
-};
-async function getTypings(schema, options) {
-	options ??= {};
-	options.declaration ??= false;
-	let wrappedSchema = schema;
-	if ((options === null || options === void 0 ? void 0 : options.declaration) && _bpinternal_zui.z.is.zuiType(schema)) {
-		const title = "title" in schema.ui ? schema.ui.title : null;
-		if (!title) throw new Error("Only schemas with \"title\" Zui property can be declared.");
-		wrappedSchema = new Declaration(schema, title);
-	}
-	let dts = await sUnwrapZodRecursive(wrappedSchema, { ...options });
-	dts = await formatTypings(dts, { throwOnError: false });
-	return dts;
 }
-async function sUnwrapZodRecursive(schema, options) {
-	return sUnwrapZod(schema, options);
+function describeParameter(parameter, index) {
+	var _parameter$ui;
+	const name = require_utils.toPropertyKey(((_parameter$ui = parameter.ui) === null || _parameter$ui === void 0 ? void 0 : _parameter$ui.title) ?? `arg${index}`);
+	const optional = _bpinternal_zui.z.is.zuiOptional(parameter) || _bpinternal_zui.z.is.zuiDefault(parameter);
+	let value = parameter;
+	while (_bpinternal_zui.z.is.zuiOptional(value) || _bpinternal_zui.z.is.zuiDefault(value)) value = value._def.innerType;
+	return `${require_utils.getMultilineComment(parameter.description)}${name}${optional ? "?" : ""}: ${schemaToTypeScript(value.describe(""))}`;
 }
-async function sUnwrapZod(schema, options) {
-	const newOptions = {
-		...options,
-		declaration: false,
-		parent: schema
-	};
-	if (schema instanceof Declaration) {
-		const description = require_utils.getMultilineComment(schema.schema.description);
-		const typings = await sUnwrapZodRecursive(schema.schema.describe(""), {
-			...newOptions,
-			declaration: true
-		});
-		const closingTag = typings.split("\n").length >= LARGE_DECLARATION_LINES ? `// end of ${schema.identifier}` : "";
-		if (_bpinternal_zui.z.is.zuiFunction(schema.schema)) return stripSpaces(`${description}
-declare function ${schema.identifier}${typings};${closingTag}`);
-		return stripSpaces(`${description}
-declare const ${schema.identifier}: ${typings};${closingTag}`);
-	}
-	if (schema instanceof KeyValue) {
-		if (_bpinternal_zui.z.is.zuiOptional(schema.value) || _bpinternal_zui.z.is.zuiDefault(schema.value)) {
-			let innerType = schema.value._def.innerType;
-			if (_bpinternal_zui.z.is.zuiType(innerType) && !innerType.description && schema.value.description) innerType = innerType === null || innerType === void 0 ? void 0 : innerType.describe(schema.value.description);
-			const optionalToken = schema.key.endsWith("?") ? "" : "?";
-			return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
-		}
-		const description = require_utils.getMultilineComment(schema.value._def.description || schema.value.description);
-		const delimiter = (description === null || description === void 0 ? void 0 : description.trim().length) > 0 ? "\n" : "";
-		const withoutDesc = schema.value.describe("");
-		return `${delimiter}${description}${delimiter}${schema.key}: ${await sUnwrapZodRecursive(withoutDesc, newOptions)}${delimiter}`;
-	}
-	if (schema instanceof FnParameters) {
-		if (_bpinternal_zui.z.is.zuiTuple(schema.schema)) {
-			let args = "";
-			for (let i = 0; i < schema.schema.items.length; i++) {
-				var _schema$schema$items$;
-				const argName = ((_schema$schema$items$ = schema.schema.items[i]) === null || _schema$schema$items$ === void 0 || (_schema$schema$items$ = _schema$schema$items$.ui) === null || _schema$schema$items$ === void 0 ? void 0 : _schema$schema$items$.title) ?? `arg${i}`;
-				const item = schema.schema.items[i];
-				args += `${await sUnwrapZodRecursive(new KeyValue(require_utils.toPropertyKey(argName), item), newOptions)}, `;
-			}
-			return args;
-		}
-		const isLiteral = _bpinternal_zui.z.is.zuiLiteral(schema.schema.naked());
-		const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
-		if (typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings) || isLiteral) return `args: ${typings}`;
-		else return typings;
-	}
-	if (schema instanceof FnReturn) {
-		if (_bpinternal_zui.z.is.zuiOptional(schema.schema)) return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
-		return sUnwrapZodRecursive(schema.schema, newOptions);
-	}
-	if (schema === null) return "unknown";
-	if (_bpinternal_zui.z.is.zuiDefault(schema)) return sUnwrapZodRecursive(schema._def.innerType, options);
-	if (_bpinternal_zui.z.is.zuiVoid(schema)) return "void";
-	if (_bpinternal_zui.z.is.zuiUnknown(schema)) return "unknown";
-	if (_bpinternal_zui.z.is.zuiAny(schema)) return "any";
-	if (_bpinternal_zui.z.is.zuiPromise(schema)) return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+/** Preserve declaration names and parameter labels; Zui renders every value type. */
+async function getTypings(schema, options = {}) {
+	var _schema$ui;
+	if (!options.declaration) return formatTypings(schemaToTypeScript(schema), { throwOnError: false });
+	const title = (_schema$ui = schema.ui) === null || _schema$ui === void 0 ? void 0 : _schema$ui.title;
+	if (typeof title !== "string" || !title) throw new require_errors.InvalidConfigurationError("Only schemas with \"title\" Zui property can be declared.");
+	const description = require_utils.getMultilineComment(schema.description);
+	let declaration;
 	if (_bpinternal_zui.z.is.zuiFunction(schema)) {
-		const description = require_utils.getMultilineComment(schema._def.description);
-		const input = await sUnwrapZodRecursive(new FnParameters(schema._def.args), newOptions);
-		const output = await sUnwrapZodRecursive(new FnReturn(schema._def.returns), newOptions);
-		if (options === null || options === void 0 ? void 0 : options.declaration) return `${description}
-(${input}): ${output}`;
-		return `${description}
-(${input}) => ${output}`;
-	}
-	if (_bpinternal_zui.z.is.zuiArray(schema)) {
-		const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
-		if (isPrimitive(item)) return `${item}[]`;
-		return `Array<${item}>`;
-	}
-	if (_bpinternal_zui.z.is.zuiEnum(schema)) return schema._def.values.map(require_utils.escapeString).join(" | ");
-	if (_bpinternal_zui.z.is.zuiTuple(schema)) {
-		if (schema.items.length === 0) return "[]";
-		return `[${(await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)))).join(", ")}]`;
-	}
-	if (_bpinternal_zui.z.is.zuiNullable(schema)) return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
-	if (_bpinternal_zui.z.is.zuiOptional(schema)) {
-		if ((options === null || options === void 0 ? void 0 : options.declaration) || _bpinternal_zui.z.is.zuiType(options === null || options === void 0 ? void 0 : options.parent) && options.parent.typeName === "ZodRecord") return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
-		const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
-		return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
-	}
-	if (_bpinternal_zui.z.is.zuiObject(schema)) return `{ ${(await Promise.all(Object.entries(schema.shape).map(async ([key, value]) => {
-		if (_bpinternal_zui.z.is.zuiType(value)) return sUnwrapZodRecursive(new KeyValue(require_utils.toPropertyKey(key), value), newOptions);
-		return `${key}: unknown`;
-	}))).join("; ")} }`;
-	if (_bpinternal_zui.z.is.zuiString(schema)) return `${require_utils.getMultilineComment(schema._def.description)} string`.trim();
-	if (_bpinternal_zui.z.is.zuiUnion(schema)) return `${require_utils.getMultilineComment(schema._def.description)}
-${(await Promise.all(schema.options.map(async (option) => {
-		return sUnwrapZodRecursive(option, newOptions);
-	}))).join(" | ")}`;
-	if (_bpinternal_zui.z.is.zuiLiteral(schema)) return `${require_utils.getMultilineComment(schema._def.description)}
-${typeof schema.value === "string" ? require_utils.escapeString(schema.value) : String(schema.value)}`.trim();
-	if (_bpinternal_zui.z.is.zuiNumber(schema)) return `${require_utils.getMultilineComment(schema._def.description)} number`.trim();
-	if (_bpinternal_zui.z.is.zuiBoolean(schema)) return `${require_utils.getMultilineComment(schema._def.description)} boolean`.trim();
-	if (_bpinternal_zui.z.is.zuiCatch(schema)) return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
-	if (_bpinternal_zui.z.is.zuiLazy(schema)) return sUnwrapZodRecursive(schema._def.getter(), newOptions);
-	if (_bpinternal_zui.z.is.zuiRecord(schema)) return `${require_utils.getMultilineComment(schema._def.description)} { [key: (${await sUnwrapZodRecursive(schema._def.keyType, newOptions)})]: (${await sUnwrapZodRecursive(schema._def.valueType, newOptions)}) }`;
-	try {
-		let typings = schema === null || schema === void 0 ? void 0 : schema.toTypescriptType({ treatDefaultAsOptional: true });
-		typings ??= "unknown";
-		return stripSpaces(typings);
-	} catch (error) {
-		console.error("Error in sUnwrapZod", {
-			error,
-			schema,
-			parent: options === null || options === void 0 ? void 0 : options.parent
-		});
-		return "unknown";
-	}
+		const input = schema.parameters();
+		declaration = `declare function ${title}(${_bpinternal_zui.z.is.zuiTuple(input) ? input.items.map(describeParameter).join(", ") : `args: ${schemaToTypeScript(input)}`}): ${schemaToTypeScript(schema.returnType())};`;
+	} else declaration = `declare const ${title}: ${schemaToTypeScript(schema.describe(""))};`;
+	return formatTypings(`${description}\n${declaration}`, { throwOnError: false });
 }
 //#endregion
 Object.defineProperty(exports, "formatTypings", {
@@ -752,28 +615,10 @@ Object.defineProperty(exports, "getTypings", {
 		return getTypings;
 	}
 });
-Object.defineProperty(exports, "isGroup", {
-	enumerable: true,
-	get: function() {
-		return isGroup;
-	}
-});
-Object.defineProperty(exports, "isPunct", {
-	enumerable: true,
-	get: function() {
-		return isPunct;
-	}
-});
-Object.defineProperty(exports, "parse", {
-	enumerable: true,
-	get: function() {
-		return parse;
-	}
-});
-Object.defineProperty(exports, "tokenize", {
+Object.defineProperty(exports, "schemaToTypeScript", {
 	enumerable: true,
 	get: function() {
-		return tokenize;
+		return schemaToTypeScript;
 	}
 });
 Object.defineProperty(exports, "typings_exports", {