llmz 0.8.0 → 1.0.1

package/dist/index.js

@@ -1,199 +1,17 @@
-import { a as StreamingMessageParser, c as NAME_REGEX, o as tryParseJson, s as MARKER } from "./common-pgJjFu2Y.js";
-import { a as Example, h as ComponentRegistry, m as validateProps, o as generateInstructions, p as validateComponent, s as DefaultComponents } from "./dual-modes-Cy0_W4O2.js";
-import { a as ThinkExit, c as ExecutionResult, d as Snapshot, f as parseExit, i as ListenExit, l as PartialExecutionResult, o as getValue, r as DefaultExit, s as ErrorExecutionResult, t as _CustomModelClient, u as SuccessExecutionResult } from "./custom-client-2V9lmzUf.js";
-import { a as getMultilineComment, c as isJsonSchema, l as isValidIdentifier, m as toValidObjectName, n as escapeString, p as toValidFunctionName, t as configureTokenizer, u as isZuiSchema, v as upperFirst } from "./utils-UBeAFeEI.js";
-import { a as isComponent, i as isAnyComponent, n as assertValidComponent, t as Component } from "./component-Dq7ZLdvy.js";
-import { t as Tool } from "./tool-Bv8N4IPj.js";
-import { c as SnapshotSignal, l as ThinkSignal, o as LoopExceededError, r as CodeFormattingError } from "./errors-Cg1G0Awu.js";
-import { a as isPunct, i as isGroup, o as parse, r as formatTypings, s as tokenize, t as getTypings } from "./typings-CrBa7Tyy.js";
-import { t as Exit } from "./exit-CDdxDBRT.js";
-import { i as wrapContent, n as truncateWrappedContent, t as stripTruncationTags } from "./truncator-DZqEqnpD.js";
-import { t as configureQuickJS } from "./quickjs-variant-BYhMBpwU.js";
-import { transforms, z } from "@bpinternal/zui";
+import { c as isValidIdentifier, f as toValidFunctionName, i as getMultilineComment, p as toValidObjectName, t as configureTokenizer } from "./utils-BOFzb8Ok.js";
+import { A as MemoryValueError, B as UnknownToolError, C as InvalidMessageError, D as LLMzError, E as InvalidToolError, F as TokenOverflowError, H as isLLMzError, I as ToolExecutionError, L as ToolInputError, M as ObjectPropertyError, N as ReservedIdentifierError, O as LoopExceededError, P as SessionStateError, R as UnknownComponentError, S as InvalidExitError, T as InvalidSessionError, V as isCriticalError, _ as InternalError, b as InvalidConfigurationError, c as CodeFormattingError, d as ComponentInputError, f as DeliveryError, g as HostOperationError, h as HookError, j as NativeProtocolError, k as MemoryCapacityError, l as CognitiveError, m as ExitInputError, n as ThinkSignal, o as AssignmentError, p as ExecutionAbortedError, s as CodeExecutionError, u as CompactionError, v as InvalidCodeError, w as InvalidObjectError, x as InvalidEventError, y as InvalidComponentError, z as UnknownExitError } from "./errors-H4JJFH3S.js";
+import { a as isAnyComponent, n as assertValidComponent, o as isComponent, t as Component } from "./component-C27qu6Zv.js";
+import { t as Tool } from "./tool--gK91eez.js";
+import { t as Exit } from "./exit-CPNk3vbz.js";
+import { r as truncate } from "./truncate-BSoH2-nY.js";
+import { f as createInspector, p as inspect, r as Memory, t as configureQuickJS } from "./quickjs-variant-DlPi9-Sx.js";
+import { i as formatTypings } from "./typings-D9_aC8aq.js";
+import { c as getValue, i as SuccessExecutionResult, l as Session, n as ErrorExecutionResult, o as DefaultExit, r as ExecutionResult, s as ListenExit, t as _CustomModelClient } from "./custom-client-BDkgBR2w.js";
+import { z } from "@bpinternal/zui";
 //#region package.json
-var version = "0.8.0";
-//#endregion
-//#region src/hoist.ts
-/**
-* Hoists object types (`{ ... }`) that appear more than once in a block of
-* typings into named `type` aliases, replacing every occurrence with a
-* reference. Runs repeatedly until a fixpoint so nested duplicates converge.
-*/
-/** Prints a node tree back to text, preserving line structure (formatTypings normalizes later) */
-function printNodes(nodes) {
-	let out = "";
-	let afterLineComment = false;
-	const emit = (n) => {
-		const newlines = Math.min(n.nl ?? 0, 2);
-		if (newlines > 0) out += "\n".repeat(newlines);
-		else if (afterLineComment) out += "\n";
-		else if (out.length && !out.endsWith("\n")) out += " ";
-		afterLineComment = false;
-		if (isGroup(n)) {
-			out += n.open;
-			for (const child of n.children) emit(child);
-			if (afterLineComment) {
-				out += "\n";
-				afterLineComment = false;
-			}
-			out += n.close;
-		} else {
-			out += n.text;
-			afterLineComment = n.kind === "line-comment";
-		}
-	};
-	for (const n of nodes) emit(n);
-	return out;
-}
-/** Canonical structural key of a type literal: comments and separators ignored */
-function keyOf(group) {
-	const parts = [];
-	const visit = (n) => {
-		if (isGroup(n)) {
-			parts.push(n.open);
-			n.children.forEach(visit);
-			parts.push(n.close);
-		} else if (n.kind === "word" || n.kind === "string" || n.kind === "punct" && n.text !== ";" && n.text !== ",") parts.push(n.text);
-	};
-	visit(group);
-	return parts.join(" ");
-}
-const prevMeaningful = (siblings, index) => {
-	for (let i = index - 1; i >= 0; i--) {
-		const n = siblings[i];
-		if (isGroup(n) || n.kind !== "block-comment" && n.kind !== "line-comment") return n;
-	}
-};
-const asName = (text) => upperFirst(text.replace(/['"]/g, "").replace(/[^A-Za-z0-9_$]/g, ""));
-/** The naming segment for a `{`/`<` group from its surrounding tokens (`key:`, `fn(...)`, `): `, `=>`) */
-function segmentsAt(siblings, index) {
-	const prev = prevMeaningful(siblings, index);
-	if (!prev || isGroup(prev)) return [];
-	if (isPunct(prev, "=>")) return ["Output"];
-	if (isPunct(prev, ":") || isPunct(prev, "<")) {
-		var _kind;
-		let i = siblings.indexOf(prev) - 1;
-		while (i >= 0 && !isGroup(siblings[i]) && ((_kind = siblings[i].kind) === null || _kind === void 0 ? void 0 : _kind.includes("comment"))) i--;
-		let q = siblings[i];
-		if (q && !isGroup(q) && q.kind === "punct" && q.text === "?") q = siblings[--i];
-		if (q && isGroup(q) && q.open === "(") {
-			const fnWord = prevMeaningful(siblings, i);
-			return fnWord && !isGroup(fnWord) && fnWord.kind === "word" ? [asName(fnWord.text), "Output"] : ["Output"];
-		}
-		if (q && !isGroup(q) && (q.kind === "word" || q.kind === "string")) return [asName(q.text)];
-	}
-	return [];
-}
-/**
-* Visits every hoistable `{ ... }` type literal with its naming path. Value
-* objects (after `=`) are skipped — except `type X = { ... }` alias bodies,
-* which are visited with their alias name so they can act as the canonical
-* definition.
-*/
-function walkLiterals(siblings, path, visit) {
-	for (let i = 0; i < siblings.length; i++) {
-		var _prevMeaningful;
-		const node = siblings[i];
-		if (!isGroup(node)) continue;
-		if (node.open === "(") {
-			const fnWord = prevMeaningful(siblings, i);
-			const fnName = fnWord && !isGroup(fnWord) && fnWord.kind === "word" ? [asName(fnWord.text)] : [];
-			walkLiterals(node.children, [...path, ...fnName], visit);
-			continue;
-		}
-		if (node.open === "<" || node.open === "[") {
-			walkLiterals(node.children, [...path, ...segmentsAt(siblings, i)], visit);
-			continue;
-		}
-		const prev = prevMeaningful(siblings, i);
-		if (prev && isPunct(prev, "=")) {
-			const eqIdx = siblings.indexOf(prev);
-			const nameTok = siblings[eqIdx - 1];
-			const typeTok = siblings[eqIdx - 2];
-			if (!(nameTok && typeTok && !isGroup(nameTok) && !isGroup(typeTok) && nameTok.kind === "word" && typeTok.kind === "word" && typeTok.text === "type")) continue;
-			const aliasName = nameTok.text;
-			visit({
-				siblings,
-				index: i,
-				group: node,
-				path: [aliasName],
-				aliasName
-			});
-			if (siblings[i] === node) walkLiterals(node.children, [aliasName], visit);
-			continue;
-		}
-		const namespaceLike = prev && !isGroup(prev) && prev.kind === "word" && ((_prevMeaningful = prevMeaningful(siblings, siblings.indexOf(prev))) === null || _prevMeaningful === void 0 ? void 0 : _prevMeaningful.kind) === "word" && ["namespace", "module"].includes(prevMeaningful(siblings, siblings.indexOf(prev)).text);
-		const segments = segmentsAt(siblings, i);
-		const newPath = [...path, ...segments];
-		if (!namespaceLike) visit({
-			siblings,
-			index: i,
-			group: node,
-			path: newPath
-		});
-		if (siblings[i] === node) walkLiterals(node.children, namespaceLike ? [...path, asName(prev.text)] : newPath, visit);
-	}
-}
-function extractAndHoistTypes(code) {
-	const top = parse(tokenize(code));
-	const counts = /* @__PURE__ */ new Map();
-	const aliasByKey = /* @__PURE__ */ new Map();
-	const usedNames = /* @__PURE__ */ new Set();
-	walkLiterals(top, [], ({ group, path, aliasName }) => {
-		const key = keyOf(group);
-		counts.set(key, (counts.get(key) ?? 0) + 1);
-		if (aliasName && !aliasByKey.has(key)) aliasByKey.set(key, aliasName);
-		for (const segment of path) usedNames.add(segment);
-		if (aliasName) usedNames.add(aliasName);
-	});
-	const uniqueName = (base) => {
-		let name = base;
-		let counter = 1;
-		while (usedNames.has(name)) name = `${base}${counter++}`;
-		usedNames.add(name);
-		return name;
-	};
-	const newAliases = [];
-	walkLiterals(top, [], ({ siblings, index, group, aliasName, path }) => {
-		const key = keyOf(group);
-		if ((counts.get(key) ?? 0) < 2 || aliasName) return;
-		let name = aliasByKey.get(key);
-		if (!name) {
-			const deduped = [...new Set(path)];
-			name = uniqueName(deduped.length ? deduped.join("") : "UnnamedType");
-			aliasByKey.set(key, name);
-			newAliases.push(`type ${name} = ${printNodes([{
-				...group,
-				nl: 0
-			}])}`);
-		}
-		siblings[index] = {
-			kind: "word",
-			text: name,
-			nl: group.nl
-		};
-	});
-	const body = printNodes(top);
-	return newAliases.length ? `${newAliases.join("\n")}\n${body}` : body;
-}
-async function hoistTypings(code, formatOptions) {
-	formatOptions ??= {};
-	formatOptions.throwOnError ??= true;
-	for (let i = 1; i <= 5; i++) try {
-		const initialCode = code;
-		code = extractAndHoistTypes(code);
-		if (initialCode === code) break;
-	} catch (err) {
-		console.error(err);
-		if (formatOptions.throwOnError) throw new CodeFormattingError(err instanceof Error ? err.message : String(err ?? "Unknown Error"), code);
-		break;
-	}
-	return formatTypings(code, formatOptions);
-}
+var version = "1.0.1";
 //#endregion
 //#region src/objects.ts
-/** How many lines of code an object needs to have before we insert a comment for end tag */
-const LARGE_OBJECT_LINES_OF_CODE = 10;
 /**
 * ObjectInstance creates stateful, namespace-scoped objects for LLMz agents.
 *
@@ -372,25 +190,6 @@ const LARGE_OBJECT_LINES_OF_CODE = 10;
 * })
 * ```
 *
-* ## TypeScript Integration
-*
-* Objects generate TypeScript namespace declarations:
-*
-* ```typescript
-* // Generated types for the LLM context:
-* export namespace user {
-*   const name: Writable<string | null> = null
-*   const age: Writable<number | null> = null
-*   const id: Readonly<string> = "user_123"
-* }
-*
-* export namespace fs {
-*   function readFile(args: { path: string }): Promise<string>
-*   function writeFile(args: { path: string, content: string }): Promise<void>
-* }
-* ```
-*
-* @see {@link https://github.com/botpress/botpress/blob/master/packages/llmz/examples/09_chat_variables/index.ts} Example usage
 */
 var ObjectInstance = class {
 	name;
@@ -456,18 +255,19 @@ var ObjectInstance = class {
 	*/
 	constructor(props) {
 		var _props$properties;
-		if (!isValidIdentifier(props.name)) throw new Error(`Invalid name for tool ${props.name}. A tool name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`);
-		if (props.description !== void 0 && typeof props.description !== "string") throw new Error(`Invalid description for tool ${props.name}. Expected a string, but got type "${typeof props.description}"`);
-		if (props.metadata !== void 0 && typeof props.metadata !== "object") throw new Error(`Invalid metadata for tool ${props.name}. Expected an object, but got type "${typeof props.metadata}"`);
-		if (props.properties !== void 0 && !Array.isArray(props.properties)) throw new Error(`Invalid properties for tool ${props.name}. Expected an array, but got type "${typeof props.properties}"`);
-		if (props.tools !== void 0 && !Array.isArray(props.tools)) throw new Error(`Invalid tools for tool ${props.name}. Expected an array, but got type "${typeof props.tools}"`);
+		if (!props || typeof props !== "object" || Array.isArray(props)) throw new InvalidObjectError("Object definition must be an object.");
+		if (!isValidIdentifier(props.name)) throw new InvalidObjectError(`Invalid name for tool ${props.name}. A tool name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`);
+		if (props.description !== void 0 && typeof props.description !== "string") throw new InvalidObjectError(`Invalid description for tool ${props.name}. Expected a string, but got type "${typeof props.description}"`);
+		if (props.metadata !== void 0 && typeof props.metadata !== "object") throw new InvalidObjectError(`Invalid metadata for tool ${props.name}. Expected an object, but got type "${typeof props.metadata}"`);
+		if (props.properties !== void 0 && !Array.isArray(props.properties)) throw new InvalidObjectError(`Invalid properties for tool ${props.name}. Expected an array, but got type "${typeof props.properties}"`);
+		if (props.tools !== void 0 && !Array.isArray(props.tools)) throw new InvalidObjectError(`Invalid tools for tool ${props.name}. Expected an array, but got type "${typeof props.tools}"`);
 		if ((_props$properties = props.properties) === null || _props$properties === void 0 ? void 0 : _props$properties.length) {
-			if (props.properties.length > 100) throw new Error(`Too many properties for tool ${props.name}. Expected at most 100 properties, but got ${props.properties.length}`);
+			if (props.properties.length > 100) throw new InvalidObjectError(`Too many properties for tool ${props.name}. Expected at most 100 properties, but got ${props.properties.length}`);
 			for (const prop of props.properties) {
-				if (props.properties.filter((p) => p.name === prop.name).length > 1) throw new Error(`Duplicate property name "${prop.name}" in tool ${props.name}`);
-				if (!isValidIdentifier(prop.name)) throw new Error(`Invalid name for property ${prop.name}. A property name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`);
-				if (prop.description !== void 0 && typeof prop.description !== "string") throw new Error(`Invalid description for property ${prop.name}. Expected a string, but got type "${typeof prop.description}"`);
-				if (props.description && props.description.length >= 5e3) throw new Error(`Description for property ${prop.name} is too long. Expected at most 5000 characters, but got ${props.description.length}`);
+				if (props.properties.filter((p) => p.name === prop.name).length > 1) throw new InvalidObjectError(`Duplicate property name "${prop.name}" in tool ${props.name}`);
+				if (!isValidIdentifier(prop.name)) throw new InvalidObjectError(`Invalid name for property ${prop.name}. A property name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`);
+				if (prop.description !== void 0 && typeof prop.description !== "string") throw new InvalidObjectError(`Invalid description for property ${prop.name}. Expected a string, but got type "${typeof prop.description}"`);
+				if (props.description && props.description.length >= 5e3) throw new InvalidObjectError(`Description for property ${prop.name} is too long. Expected at most 5000 characters, but got ${props.description.length}`);
 				if (typeof prop.writable !== "boolean") prop.writable = false;
 			}
 		}
@@ -477,45 +277,17 @@ var ObjectInstance = class {
 		this.properties = props.properties;
 		this.tools = Tool.withUniqueNames(props.tools ?? []);
 	}
-	/**
-	* Generates TypeScript namespace declarations for this object.
-	*
-	* This method creates TypeScript definitions that are included in the LLM context
-	* to help it understand the available properties and tools. Properties become
-	* const declarations with appropriate Readonly/Writable types, and tools become
-	* function signatures.
-	*
-	* @returns Promise resolving to TypeScript namespace declaration
-	*
-	* @example
-	* ```typescript
-	* const obj = new ObjectInstance({
-	*   name: 'user',
-	*   properties: [
-	*     { name: 'name', value: 'John', writable: true },
-	*     { name: 'id', value: 123, writable: false },
-	*   ],
-	*   tools: [
-	*     new Tool({
-	*       name: 'save',
-	*       input: z.object({ data: z.string() }),
-	*       handler: async ({ data }) => { /* ... *\/ },
-	*     }),
-	*   ],
-	* })
-	*
-	* const typings = await obj.getTypings()
-	* console.log(typings)
-	* // Output:
-	* // export namespace user {
-	* //   const name: Writable<string> = "John"
-	* //   const id: Readonly<number> = 123
-	* //   function save(args: { data: string }): Promise<void>
-	* // }
-	* ```
-	*/
-	async getTypings() {
-		return getObjectTypings(this).withProperties().withTools().build();
+	/** Callable API only. Property values, schemas, and access rules belong in Memory. */
+	async getToolTypings() {
+		var _this$description;
+		const declarations = [];
+		for (const tool of this.tools ?? []) {
+			const declaration = await tool.getTypings();
+			declarations.push(declaration.replace("declare function ", "function "));
+		}
+		const description = ((_this$description = this.description) === null || _this$description === void 0 ? void 0 : _this$description.trim()) ? getMultilineComment(this.description) : "";
+		const body = declarations.join("\n\n");
+		return formatTypings(`${description}\nexport namespace ${this.name} {\n${body}\n}`, { throwOnError: false });
 	}
 	/**
 	* Converts this ObjectInstance to its JSON representation.
@@ -536,123 +308,36 @@ var ObjectInstance = class {
 		};
 	}
 };
+//#endregion
+//#region src/chat/chat.ts
 /**
-* Creates a TypeScript namespace builder for an ObjectInstance.
-*
-* This function provides a fluent API for generating TypeScript declarations
-* that include properties, tools, or both. It's used internally by ObjectInstance.getTypings().
-*
-* @param obj - The ObjectInstance to generate typings for
-* @returns A builder object with methods to configure and build the namespace
-* @internal
-*/
-function getObjectTypings(obj) {
-	let includeProperties = false;
-	let includeTools = false;
-	let hoisting = false;
-	const typings = [];
-	const addProperties = async () => {
-		var _obj$properties;
-		if (includeProperties && ((_obj$properties = obj.properties) === null || _obj$properties === void 0 ? void 0 : _obj$properties.length)) {
-			typings.push("");
-			typings.push("// ---------------- //");
-			typings.push("//    Properties    //");
-			typings.push("// ---------------- //");
-			typings.push("");
-			for (const prop of obj.properties ?? []) {
-				const description = prop.description ?? "";
-				if (description === null || description === void 0 ? void 0 : description.trim().length) typings.push(getMultilineComment(description));
-				let type = "unknown";
-				if (prop.type) type = await getTypings(prop.type, {});
-				else if (prop.value !== void 0) type = typeof prop.value;
-				type = prop.writable ? `Writable<${type}>` : `Readonly<${type}>`;
-				const value = embedPropertyValue(prop);
-				typings.push(`const ${prop.name}: ${type} = ${value}`);
-			}
-		}
-	};
-	const addTools = async () => {
-		var _obj$tools;
-		if (includeTools && ((_obj$tools = obj.tools) === null || _obj$tools === void 0 ? void 0 : _obj$tools.length)) {
-			typings.push("");
-			typings.push("// ---------------- //");
-			typings.push("//       Tools      //");
-			typings.push("// ---------------- //");
-			typings.push("");
-			for (const tool of obj.tools) {
-				const fnType = z.function(tool.zInput, tool.zOutput).title(tool.name).describe(tool.description ?? "");
-				let temp = await getTypings(fnType, { declaration: true });
-				temp = temp.replace("declare function ", "function ");
-				typings.push(temp);
-			}
-		}
-	};
-	const finalize = async () => {
-		var _obj$description;
-		let closingBracket = "";
-		if (typings.length >= LARGE_OBJECT_LINES_OF_CODE) closingBracket = ` // end namespace "${obj.name}"`;
-		let body = typings.join("\n");
-		if (hoisting) body = await hoistTypings(body, { throwOnError: false });
-		typings.push("}" + closingBracket);
-		let header = "";
-		if ((_obj$description = obj.description) === null || _obj$description === void 0 ? void 0 : _obj$description.trim().length) header = getMultilineComment(obj.description);
-		return formatTypings(`${header}
-      export namespace ${obj.name} {
-      ${body}
-      } ${closingBracket}`.trim(), { throwOnError: false });
-	};
-	const api = {
-		withProperties: () => {
-			includeProperties = true;
-			return api;
-		},
-		withTools: () => {
-			includeTools = true;
-			return api;
-		},
-		withHoisting: () => {
-			hoisting = true;
-			return api;
-		},
-		async build() {
-			await addProperties();
-			await addTools();
-			return finalize();
-		}
-	};
-	return api;
-}
-/**
-* Converts a property value to its TypeScript literal representation.
+* Connects native assistant replies and rich components to the host application.
 *
-* This function handles the serialization of various JavaScript types into
-* TypeScript code that can be embedded in generated namespace declarations.
-* It supports primitives, objects, arrays, dates, regex, and other common types.
+* `response` controls how all assistant text is written. It does not create a
+* JavaScript method or synthesize audio. `components` registers only rich UI
+* methods such as chat.buttons or chat.image.
 *
-* @param property - The ObjectProperty containing the value to embed
-* @returns String representation of the value for use in TypeScript code
-* @internal
+* Streamed deltas are provisional. After successful generation, the response
+* handler receives the complete text with the same message ID. Each component
+* owns its delivery handler. Without response callbacks, text remains available
+* in the native session history.
 */
-function embedPropertyValue(property) {
-	if (typeof property.value === "string") return escapeString(property.value);
-	if (Number.isNaN(property.value)) return "NaN";
-	if (typeof property.value === "number" && Number.isInteger(property.value)) return property.value.toString();
-	if (typeof property.value === "boolean") return property.value.toString();
-	if (Array.isArray(property.value) || typeof property.value === "object") return JSON.stringify(property.value);
-	if (property.value instanceof Date) return `new Date('${property.value.toISOString()}')`;
-	if (property.value instanceof RegExp) return `new RegExp(${escapeString(property.value.source)}, ${escapeString(property.value.flags)})`;
-	if (property.value === null) return "null";
-	if (property.value === void 0) return "undefined";
-	if (typeof property.value === "function") return "function() {}";
-	if (typeof property.value === "symbol") return "Symbol()";
-	if (typeof property.value === "bigint") return `${property.value}n`;
-	if (property.value instanceof Error) return `Error(${escapeString(property.value.message)})`;
-	if (property.value instanceof Map) return `new Map(${JSON.stringify(Array.from(property.value.entries()))})`;
-	if (property.value instanceof Set) return `new Set(${JSON.stringify(Array.from(property.value.values()))})`;
-	return "unknown";
-}
+var Chat = class {
+	components;
+	response;
+	constructor(props = {}) {
+		if (!props || typeof props !== "object" || Array.isArray(props)) throw new InvalidConfigurationError("Chat configuration must be an object.");
+		if ("handler" in props || "onMessageDelta" in props) throw new InvalidConfigurationError("Use response.handler and response.onDelta for text, and component handlers for rich messages.");
+		const unknown = Object.keys(props).find((key) => !["components", "response"].includes(key));
+		if (unknown) throw new InvalidConfigurationError(`Unknown Chat option: ${unknown}.`);
+		this.components = props.components ?? [];
+		this.response = props.response === void 0 ? "markdown" : props.response;
+	}
+	/** Called after an execution completes or fails. */
+	onExecutionDone(_result) {}
+};
 //#endregion
-//#region src/citations.ts
+//#region src/chat/citations.ts
 /** These are all single-token symbols that are very rare in natural texts, making them suitable for usage within GPT Prompts. */
 const RARE_SYMBOLS = {
 	ARROW_UP: "↑",
@@ -791,611 +476,95 @@ var CitationsManager = class {
 	}
 };
 //#endregion
-//#region src/chat.ts
-/**
-* Base class for implementing chat interfaces in LLMz agents.
-*
-* The Chat class provides the foundation for interactive conversational agents by defining
-* how agents communicate with users. It manages the conversation transcript, available UI
-* components, and message handling. This is the bridge between the agent's generated code
-* and your user interface.
-*
-* ## Key Concepts
-*
-* **Handler Function**: The core method that receives agent messages (rendered components)
-* and displays them to the user. This is called every time the agent wants to communicate.
-*
-* **Transcript**: An up-to-date conversation history that is evaluated at each iteration.
-* The transcript must reflect the complete conversation state as the agent uses it to
-* understand context and generate appropriate responses.
-*
-* **Components**: The UI elements available to the agent for creating rich interactive
-* experiences (text, buttons, images, cards, etc.).
-*
-* ## Implementation Requirements
-*
-* To create a functional chat interface, you must:
-* 1. Implement the MessageHandler to display agent messages to users
-* 2. Maintain an accurate transcript of the conversation
-* 3. Provide the available UI components (typically includes DefaultComponents)
-* 4. Optional: Override onExecutionDone() to handle execution completion
-*
-* ## Basic Implementation
-*
-* ```typescript
-* import { Chat, DefaultComponents, isComponent } from 'llmz'
-*
-* class MyChat extends Chat {
-*   private messages: Array<{role: 'user' | 'assistant', content: string}> = []
-*
-*   constructor() {
-*     super({
-*       // Handle agent messages - this is called for every agent output
-*       handler: async (input) => {
-*         if (isComponent(input, DefaultComponents.Text)) {
-*           const text = input.children.join('')
-*           console.log('Agent:', text)
-*           this.messages.push({ role: 'assistant', content: text })
-*         } else if (isComponent(input, DefaultComponents.Button)) {
-*           console.log('Button:', input.props.label)
-*         }
-*       },
-*
-*       // Provide available components - agent can use these in generated code
-*       components: [DefaultComponents.Text, DefaultComponents.Button],
-*
-*       // Return current transcript - evaluated at each iteration
-*       transcript: () => this.messages,
-*     })
-*   }
-*
-*   // Add user message to transcript
-*   addUserMessage(content: string) {
-*     this.messages.push({ role: 'user', content })
-*   }
-* }
-*
-* // Usage
-* const chat = new MyChat()
-* chat.addUserMessage('Hello!')
-*
-* const result = await execute({
-*   instructions: 'You are a helpful assistant',
-*   chat, // Enable chat mode
-*   client,
-* })
-* ```
-*
-* ## Advanced Implementation (CLIChat Example)
-*
-* ```typescript
-* import { Chat, DefaultComponents, ListenExit } from 'llmz'
-*
-* class CLIChat extends Chat {
-*   public transcript: Array<{role: 'user' | 'assistant', content: string}> = []
-*   private buttons: string[] = []
-*   public result?: ExecutionResult
-*
-*   constructor() {
-*     super({
-*       // Dynamic component list with custom renderers
-*       components: () => [
-*         DefaultComponents.Text,
-*         DefaultComponents.Button,
-*         ...this.customComponents
-*       ],
-*
-*       // Dynamic transcript access
-*       transcript: () => this.transcript,
-*
-*       // Sophisticated message handling
-*       handler: async (input) => {
-*         if (isComponent(input, DefaultComponents.Text)) {
-*           const text = input.children.join('')
-*           console.log('🤖 Agent:', text)
-*           this.transcript.push({ role: 'assistant', content: text })
-*         } else if (isComponent(input, DefaultComponents.Button)) {
-*           this.buttons.push(input.props.label)
-*         }
-*       },
-*     })
-*   }
-*
-*   // Handle execution completion
-*   onExecutionDone(result: ExecutionResult) {
-*     this.result = result
-*   }
-*
-*   // Check if agent is waiting for user input
-*   isWaitingForInput(): boolean {
-*     return this.result?.is(ListenExit) ?? false
-*   }
-*
-*   // Conversation loop
-*   async iterate(): Promise<boolean> {
-*     if (this.isWaitingForInput()) {
-*       const userInput = await this.promptUser()
-*       this.transcript.push({ role: 'user', content: userInput })
-*       return true // Continue conversation
-*     }
-*     return false // End conversation
-*   }
-* }
-* ```
-*
-* ## Component System
-*
-* The agent generates JSX code using available components:
-*
-* ```typescript
-* // Agent generates this TSX code:
-* yield <Text>Welcome! Choose an option:</Text>
-* yield <Button action="postback" label="Get Help" value="help" />
-* yield <Button action="postback" label="Contact Sales" value="sales" />
-*
-* // Your handler receives these as RenderedComponent objects
-* ```
-*
-* ## Transcript Management
-*
-* The transcript is critical for agent context and must be kept up-to-date:
-*
-* ```typescript
-* // ❌ Bad - static transcript
-* transcript: [{ role: 'user', content: 'Hello' }]
-*
-* // ✅ Good - dynamic transcript that reflects current state
-* transcript: () => this.messages
-*
-* // The transcript is evaluated at each iteration, so the agent
-* // always sees the current conversation state
-* ```
-*
-* ## Custom Components
-*
-* Extend the UI with custom components for your specific use case:
-*
-* ```typescript
-* import { Component } from 'llmz'
-*
-* const ProductCard = new Component({
-*   type: 'leaf',
-*   name: 'ProductCard',
-*   leaf: {
-*     props: z.object({
-*       name: z.string(),
-*       price: z.number(),
-*       imageUrl: z.string(),
-*     })
-*   }
-* })
-*
-* class ShoppingChat extends Chat {
-*   constructor() {
-*     super({
-*       components: [
-*         ...DefaultComponents,
-*         ProductCard, // Add custom component
-*       ],
-*       handler: async (input) => {
-*         if (isComponent(input, ProductCard)) {
-*           // Handle custom component rendering
-*           this.renderProduct(input.props)
-*         }
-*         // ... handle other components
-*       },
-*     })
-*   }
-* }
-* ```
-*
-* @see {@link DefaultComponents} For standard UI components
-* @see {@link https://github.com/botpress/botpress/blob/master/packages/llmz/examples/utils/cli-chat.ts} Complete CLIChat implementation
-*/
-var Chat = class {
-	handler;
-	onMessageDelta;
-	transcript;
-	components;
-	/**
-	* Creates a new Chat instance.
-	*
-	* @param props - Chat configuration
-	* @param props.handler - Function to handle agent messages (called for every agent output)
-	* @param props.components - Available UI components (static array or dynamic function)
-	* @param props.transcript - Conversation history (static array or dynamic function, defaults to empty)
-	*
-	* @example
-	* ```typescript
-	* // Basic chat with static configuration
-	* const chat = new Chat({
-	*   handler: async (input) => {
-	*     if (isComponent(input, DefaultComponents.Text)) {
-	*       console.log('Agent:', input.children.join(''))
-	*     }
-	*   },
-	*   components: [DefaultComponents.Text, DefaultComponents.Button],
-	*   transcript: [
-	*     { role: 'user', content: 'Hello', timestamp: Date.now() }
-	*   ],
-	* })
-	* ```
-	*
-	* @example
-	* ```typescript
-	* // Dynamic chat with functions for real-time updates
-	* class MyChat extends Chat {
-	*   private messages: Transcript.Message[] = []
-	*
-	*   constructor() {
-	*     super({
-	*       handler: (input) => this.handleMessage(input),
-	*
-	*       // Dynamic components - can change during execution
-	*       components: () => [
-	*         DefaultComponents.Text,
-	*         DefaultComponents.Button,
-	*         ...this.getCustomComponents()
-	*       ],
-	*
-	*       // Dynamic transcript - always reflects current state
-	*       transcript: () => this.messages,
-	*     })
-	*   }
-	* }
-	* ```
-	*/
-	constructor(props) {
-		this.handler = props.handler;
-		this.onMessageDelta = props.onMessageDelta;
-		this.components = props.components;
-		this.transcript = props.transcript || [];
-	}
-	/**
-	* Called when an execution cycle completes, regardless of the outcome.
-	*
-	* Override this method to handle execution results, manage conversation flow,
-	* or perform cleanup tasks. This is called after each `execute()` call completes,
-	* whether it succeeds, fails, or is interrupted.
-	*
-	* @param result - The execution result containing status, iterations, and exit information
-	*
-	* @example
-	* ```typescript
-	* class MyChat extends Chat {
-	*   public result?: ExecutionResult
-	*
-	*   onExecutionDone(result: ExecutionResult) {
-	*     // Store result for conversation flow control
-	*     this.result = result
-	*
-	*     // Handle different result types
-	*     if (result.isSuccess()) {
-	*       console.log('✅ Execution completed successfully')
-	*       console.log('Exit:', result.output.exit_name)
-	*     } else if (result.isError()) {
-	*       console.error('❌ Execution failed:', result.output.error)
-	*     } else if (result.isInterrupted()) {
-	*       console.log('⏸️ Execution interrupted (partial result)')
-	*     }
-	*   }
-	*
-	*   // Use stored result for conversation flow
-	*   isWaitingForInput(): boolean {
-	*     return this.result?.is(ListenExit) ?? false
-	*   }
-	* }
-	* ```
-	*
-	* @example
-	* ```typescript
-	* // CLIChat implementation example
-	* class CLIChat extends Chat {
-	*   public status?: IterationStatus
-	*   public result?: ExecutionResult
-	*
-	*   onExecutionDone(result: ExecutionResult) {
-	*     this.result = result
-	*     this.status = result.iterations.at(-1)?.status
-	*   }
-	*
-	*   // Check if agent exited with specific exit type
-	*   hasExitedWith<R>(exit: Exit<R>): boolean {
-	*     return this.status?.type === 'exit_success' &&
-	*            this.status.exit_success.exit_name === exit.name
-	*   }
-	* }
-	* ```
-	*/
-	onExecutionDone(_result) {}
+//#region src/chat/component.default.ts
+const buttonProps = z.object({
+	action: z.enum([
+		"say",
+		"url",
+		"postback"
+	]).default("say").describe("The action to perform when the button is clicked: say, url, or postback"),
+	label: z.string().min(1).max(250).describe("The text displayed on the button (1–250 characters)"),
+	value: z.string().optional().describe("The postback value. Required when action is postback"),
+	url: z.string().optional().describe("The URL to open. Required when action is url")
+}).strict();
+const imageProps = z.object({
+	url: z.string().describe("The URL of the image (must be valid)"),
+	alt: z.string().optional().describe("Alternative text describing the image")
+}).strict();
+const cardProps = z.object({
+	title: z.string().min(1).max(250).describe("Title text (1–250 characters)"),
+	subtitle: z.string().optional().describe("Optional subtitle for the card"),
+	text: z.string().optional().describe("Optional Markdown text for the card"),
+	image: imageProps.optional().describe("Optional image for the card; use a known URL"),
+	buttons: z.array(buttonProps).max(5).optional().describe("Up to 5 actions for the card")
+}).strict();
+const DefaultComponents = {
+	Buttons: new Component({
+		name: "buttons",
+		description: "Offer quick actions or choices after a message. Buttons appear together in array order.",
+		props: z.array(buttonProps).min(1)
+	}),
+	Image: new Component({
+		name: "image",
+		description: "Display an image using a known URL from the user or tool results; never invent an image URL.",
+		props: imageProps
+	}),
+	File: new Component({
+		name: "file",
+		description: "Send a downloadable file to the user.",
+		props: z.object({
+			url: z.string().describe("The URL of the file (must be valid)"),
+			name: z.string().optional().describe("The display name of the file")
+		}).strict()
+	}),
+	Video: new Component({
+		name: "video",
+		description: "Embed a video from a URL.",
+		props: z.object({
+			url: z.string().describe("The URL of the video (must be valid)"),
+			title: z.string().optional().describe("Title for the video")
+		}).strict()
+	}),
+	Audio: new Component({
+		name: "audio",
+		description: "Play an audio clip from a URL.",
+		props: z.object({
+			url: z.string().describe("The URL of the audio clip (must be valid)"),
+			title: z.string().optional().describe("Title for the audio clip")
+		}).strict()
+	}),
+	Card: new Component({
+		name: "card",
+		description: "Present one item with a title, optional subtitle, Markdown text, image, and buttons.",
+		props: cardProps
+	}),
+	Carousel: new Component({
+		name: "carousel",
+		description: "Display several comparable items as a horizontally scrollable collection of cards.",
+		props: z.object({ cards: z.array(cardProps).min(1).max(10).describe("1–10 cards in display order, each with its own content and actions") }).strict()
+	})
 };
 //#endregion
-//#region src/message-stream/replayable.ts
-/**
-* Wraps an async iterable so it can be iterated multiple times: chunks pulled
-* from the source are cached, and every iteration replays the cache before
-* pulling new chunks. Concurrent iterations are safe — pulls on the underlying
-* source are serialized. If the source fails, the failure is cached too:
-* every iteration replays the chunks received before the failure, then
-* rethrows the source error.
-*/
-var ReplayableAsyncIterable = class {
-	_source;
-	_chunks = [];
-	_done = false;
-	_failed = false;
-	_error;
-	_lock = Promise.resolve();
-	constructor(source) {
-		this._source = source[Symbol.asyncIterator]();
-	}
-	/** True once the underlying source has been fully consumed (or has failed). */
-	get done() {
-		return this._done;
-	}
-	/** The chunks pulled from the source so far. */
-	get chunks() {
-		return [...this._chunks];
-	}
-	async *[Symbol.asyncIterator]() {
-		let index = 0;
-		while (true) if (index < this._chunks.length) yield this._chunks[index++];
-		else if (this._failed) throw this._error;
-		else if (this._done) return;
-		else await this._pull();
-	}
-	/** Consumes the entire source and returns all chunks. */
-	async collect() {
-		for await (const _ of this);
-		return this.chunks;
-	}
-	_pull() {
-		const next = this._lock.then(async () => {
-			if (this._done) return;
-			let result;
-			try {
-				result = await this._source.next();
-			} catch (thrown) {
-				this._done = true;
-				this._failed = true;
-				this._error = thrown;
-				throw thrown;
-			}
-			if (result.done) this._done = true;
-			else this._chunks.push(result.value);
-		});
-		this._lock = next.catch(() => {});
-		return next;
-	}
-};
-/** Drains a string iterable into a single string. */
-const collectText = async (iterable) => {
-	let text = "";
-	for await (const chunk of iterable) text += chunk;
-	return text;
-};
-//#endregion
-//#region src/message-stream/stream.ts
-var BaseResponse = class {
-	action;
-	item;
-	constructor(action, item) {
-		this.action = action;
-		this.item = item;
-	}
-	get diagnostics() {
-		return this.item.diagnostics;
-	}
-};
-/** `■send=<component> { props? }` followed by an optional streaming body. */
-var SendResponse = class extends BaseResponse {
-	content;
-	constructor(item, content) {
-		super("send", item);
-		this.content = content;
-	}
-	get component() {
-		return this.item.name;
-	}
-	get props() {
-		return this.item.props;
-	}
-	static formatToText(component, props, body) {
-		const header = `■send=${component}${props && Object.keys(props).length ? ` ${JSON.stringify(props)}` : ""}`;
-		return body ? `${header}\n${body}` : header;
-	}
-};
-/** `■run` followed by streaming code. */
-var RunResponse = class extends BaseResponse {
-	code;
-	constructor(item, code) {
-		super("run", item);
-		this.code = code;
-	}
-	static formatToText(code) {
-		return `■run\n${code}`;
-	}
-};
-/** `■next=<name> { props? }` — hands control to an exit (e.g. listen) with optional props. */
-var NextResponse = class extends BaseResponse {
-	constructor(item) {
-		super("next", item);
-	}
-	get name() {
-		return this.item.name;
-	}
-	get props() {
-		return this.item.props;
-	}
-	static formatToText(name, props) {
-		return `■next=${name}${props && Object.keys(props).length ? ` ${JSON.stringify(props)}` : ""}`;
-	}
-};
-/**
-* Pulls transport chunks through the parser on demand and hands out events one
-* at a time. Shared by the main response loop and by body streams; pulls are
-* serialized so interleaved consumers cannot race the source iterator.
-*/
-var EventPump = class {
-	_iterator;
-	_parser;
-	_queue = [];
-	_sourceDone = false;
-	_lock = Promise.resolve();
-	constructor(stream, parser) {
-		this._iterator = stream[Symbol.asyncIterator]();
-		this._parser = parser;
-	}
-	next() {
-		const next = this._lock.then(() => this._next());
-		this._lock = next.catch(() => {});
-		return next;
-	}
-	unshift(event) {
-		this._queue.unshift(event);
-	}
-	async _next() {
-		while (this._queue.length === 0) {
-			if (this._sourceDone) return;
-			let result;
-			try {
-				result = await this._iterator.next();
-			} catch {
-				this._sourceDone = true;
-				this._queue.push(...this._parser.finish("interrupted"));
-				continue;
-			}
-			if (result.done) {
-				this._sourceDone = true;
-				this._queue.push(...this._parser.finish());
-			} else this._queue.push(...this._parser.push(result.value));
-		}
-		return this._queue.shift();
-	}
-};
-/**
-* Parses a raw LLM text stream into typed responses.
-*
-* `send` and `run` responses are yielded as soon as their header is parsed —
-* while their body is still streaming — with the body exposed as a replayable
-* async iterable. `next` responses are yielded once complete.
-*
-* The body streams are pull-based: consuming them drives the underlying
-* transport. Requesting the next response first drains the previous body into
-* its replay cache, so it can always be read later.
-*/
-function parseStream(stream, options) {
-	return parseResponses(stream, options);
-}
-/** Parses a complete text (convenience wrapper over {@link parseStream}). */
-function parseText(text, options) {
-	return parseResponses((async function* () {
-		yield text;
-	})(), options);
-}
-async function* parseResponses(stream, options) {
-	const pump = new EventPump(stream, new StreamingMessageParser(options));
-	let activeBody;
-	while (true) {
-		if (activeBody) {
-			await activeBody.collect();
-			activeBody = void 0;
-		}
-		const event = await pump.next();
-		if (!event) return;
-		if (event.type === "item-ready" && (event.item.kind === "send" || event.item.kind === "run")) {
-			const body = new ReplayableAsyncIterable(bodyStream(pump, event.item.id));
-			activeBody = body;
-			yield event.item.kind === "send" ? new SendResponse(event.item, body) : new RunResponse(event.item, body);
-			continue;
-		}
-		if (event.type === "item-complete" && event.item.kind === "next") {
-			yield new NextResponse(event.item);
-			continue;
-		}
-	}
-}
-async function* bodyStream(pump, itemId) {
-	while (true) {
-		const event = await pump.next();
-		if (!event) return;
-		if (event.type === "body-delta" && event.itemId === itemId) {
-			yield event.delta;
-			continue;
-		}
-		if (event.type === "body-start" && event.itemId === itemId) continue;
-		if (event.type === "diagnostic") continue;
-		if (event.type === "item-complete" && event.item.id === itemId) return;
-		pump.unshift(event);
-		return;
-	}
-}
-//#endregion
-//#region src/message-stream/normalizer.ts
-const EMPTY_PROPS_SCHEMA = {
-	type: "object",
-	properties: {},
-	additionalProperties: false
-};
-const normalizeComponentName = (name) => name.trim().toLowerCase();
-function normalizeComponentDefinition(definition) {
-	const name = normalizeComponentName(definition.name ?? "");
-	if (!NAME_REGEX.test(name)) throw new Error(`Invalid component name "${definition.name}". Component names must be lowercase ([a-z][a-z0-9_-]*).`);
-	return {
-		name,
-		description: definition.description,
-		propsJsonSchema: normalizePropsSchema(definition.props, name),
-		body: definition.body ? {
-			format: definition.body.type,
-			description: definition.body.description,
-			required: definition.body.required ?? false
-		} : void 0,
-		generation: definition.generation
-	};
-}
-function normalizePropsSchema(props, name) {
-	if (props === void 0) return EMPTY_PROPS_SCHEMA;
-	if (isZuiSchema(props)) try {
-		return transforms.toJSONSchema(props);
-	} catch {
-		return transforms.toJSONSchemaLegacy(props);
-	}
-	if (isJsonSchema(props)) return props;
-	throw new Error(`Invalid props schema for "${name}". Expected a ZUI/Zod object schema or a JSON schema, but got type "${typeof props}".`);
-}
-//#endregion
-//#region src/message-stream/sanitize.ts
-/**
-* The protocol has no escaping mechanism by design. Any untrusted text that is
-* inserted into model context (user messages, tool results, documents) must be
-* sanitized so it cannot inject protocol blocks.
-*/
-const sanitizeMessageText = (value, options = {}) => value.replaceAll("■", options.markerReplacement ?? "▪");
-//#endregion
 //#region src/index.ts
 const utils = {
 	toValidObjectName,
-	toValidFunctionName,
-	wrapContent,
-	truncateWrappedContent,
-	stripTruncationTags
+	toValidFunctionName
 };
 /**
 * Executes an LLMz agent in either Chat Mode or Worker Mode.
 *
-* LLMz is a code-first AI agent framework that generates and runs TypeScript code
-* in a sandbox rather than using traditional JSON tool calling. This enables complex
-* logic, multi-tool orchestration, and native LLM thinking via comments and code structure.
+* LLMz generates and runs JavaScript in a sandbox through the native run_javascript
+* tool. Assistant text streams normally; JavaScript returns decisions to present
+* rich messages, inspect results, or complete through a typed exit.
 *
 * @param props - Configuration object for the execution
 * @param props.client - Botpress Client or Cognitive Client instance for LLM generation
 * @param props.instructions - System prompt/instructions for the LLM (static string or dynamic function)
-* @param props.examples - Optional labeled few-shot examples (static array or dynamic function)
 * @param props.chat - Optional Chat instance to enable Chat Mode with user interaction
 * @param props.tools - Array of Tool instances available to the agent (static or dynamic)
 * @param props.objects - Array of ObjectInstance for namespaced tools and variables (static or dynamic)
 * @param props.exits - Array of Exit definitions for structured completion (static or dynamic)
-* @param props.snapshot - Optional Snapshot to resume paused execution
+* @param props.session - Conversation state; append input before execution and persist it between executions
 * @param props.signal - Optional AbortSignal to cancel execution
 * @param props.model - Optional model name (or array or models to use as fallback) (static or dynamic function)
 * @param props.temperature - Optional temperature value (static or dynamic function)
@@ -1439,7 +608,7 @@ const utils = {
 * // With dynamic instructions and hooks
 * const result = await execute({
 *   client: cognitiveClient,
-*   instructions: (ctx) => `Process ${ctx.variables.dataCount} records`,
+*   instructions: (ctx) => `Process ${ctx.session.memory.variables.dataCount} records`,
 *   tools: async (ctx) => await getContextualTools(ctx),
 *   model: 'best',
 *   temperature: 0.1,
@@ -1449,7 +618,7 @@ const utils = {
 * })
 */
 const execute = async (props) => {
-	const { executeContext } = await import("./execute-Aw4cbIx-.js");
+	const { executeContext } = await import("./execute-BYI_U5sR.js");
 	return executeContext(props);
 };
 /**
@@ -1458,16 +627,14 @@ const execute = async (props) => {
 * It's recommended to call this function at the beginning of your application without awaiting it (void init())
 */
 const init = async () => {
-	await import("./execute-Aw4cbIx-.js");
-	await import("./component-Dq7ZLdvy.js").then((n) => n.r);
-	await import("./tool-Bv8N4IPj.js").then((n) => n.n);
-	await import("./exit-CDdxDBRT.js").then((n) => n.n);
-	await import("./jsx-B0iYyvfr.js").then((n) => n.i);
-	await import("./vm-BLsHw1da.js");
-	await import("./utils-UBeAFeEI.js").then((n) => n.h);
-	await import("./truncator-DZqEqnpD.js").then((n) => n.r);
-	await import("./typings-CrBa7Tyy.js").then((n) => n.n);
-	await import("./dual-modes-Cy0_W4O2.js").then((n) => n.n);
+	await import("./execute-BYI_U5sR.js");
+	await import("./component-C27qu6Zv.js").then((n) => n.r);
+	await import("./tool--gK91eez.js").then((n) => n.n);
+	await import("./exit-CPNk3vbz.js").then((n) => n.n);
+	await import("./vm-8jxt8PTK.js");
+	await import("./utils-BOFzb8Ok.js").then((n) => n.m);
+	await import("./typings-D9_aC8aq.js").then((n) => n.r);
+	await import("./native-DvTH9vFe.js").then((n) => n.n);
 };
 //#endregion
-export { BaseResponse, Chat, CitationsManager, Component, ComponentRegistry, DefaultComponents, DefaultExit, ErrorExecutionResult, Example, ExecutionResult, Exit, ListenExit, LoopExceededError, MARKER, NAME_REGEX, NextResponse, ObjectInstance, PartialExecutionResult, ReplayableAsyncIterable, RunResponse, SendResponse, Snapshot, SnapshotSignal, StreamingMessageParser, SuccessExecutionResult, ThinkExit, ThinkSignal, Tool, _CustomModelClient, assertValidComponent, collectText, configureQuickJS, configureTokenizer, execute, generateInstructions, getValue, init, isAnyComponent, isComponent, normalizeComponentDefinition, normalizeComponentName, normalizePropsSchema, parseExit, parseStream, parseText, sanitizeMessageText, tryParseJson, utils, validateComponent, validateProps, version };
+export { AssignmentError, Chat, CitationsManager, CodeExecutionError, CodeFormattingError, CognitiveError, CompactionError, Component, ComponentInputError, DefaultComponents, DefaultExit, DeliveryError, ErrorExecutionResult, ExecutionAbortedError, ExecutionResult, Exit, ExitInputError, HookError, HostOperationError, InternalError, InvalidCodeError, InvalidComponentError, InvalidConfigurationError, InvalidEventError, InvalidExitError, InvalidMessageError, InvalidObjectError, InvalidSessionError, InvalidToolError, LLMzError, ListenExit, LoopExceededError, Memory, MemoryCapacityError, MemoryValueError, NativeProtocolError, ObjectInstance, ObjectPropertyError, ReservedIdentifierError, Session, SessionStateError, SuccessExecutionResult, ThinkSignal, TokenOverflowError, Tool, ToolExecutionError, ToolInputError, UnknownComponentError, UnknownExitError, UnknownToolError, _CustomModelClient, assertValidComponent, configureQuickJS, configureTokenizer, createInspector, execute, getValue, init, inspect, isAnyComponent, isComponent, isCriticalError, isLLMzError, truncate, utils, version };