zidane 7.2.5 → 8.0.4

package/dist/client-core-BQSyDALT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-core-BQSyDALT.d.ts","names":["OrchestrationCreateWorkerParams","OrchestrationWorkerRow","OrchestrationWorkerSummary"],"sources":["../src/ipc/protocol.ts","../src/ipc/transports/client-core.ts"],"mappings":"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"}

package/dist/codemode-worker.d.ts

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

package/dist/codemode-worker.js

@@ -0,0 +1,155 @@
+import { t as isHostToWorkerMessage } from "./protocol-DnhqqSmE.js";
+import { a as PRELUDE_SOURCE } from "./prelude-Cxo4t74B.js";
+import { parentPort, workerData } from "node:worker_threads";
+import { JSException, MAX_STACK_SIZE, QuickJS } from "quickjs-wasi";
+//#region src/codemode/runtime/worker.ts
+function post(message) {
+	parentPort?.postMessage(message);
+}
+function crash(error) {
+	post({
+		type: "crash",
+		message: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
+	});
+}
+/** WASI `errno` for success. */
+const ESUCCESS = 0;
+/**
+* WASI overrides. QuickJS writes engine diagnostics to fd 1 and 2, which the
+* default shim forwards to the host's stdout and stderr. That output belongs to
+* the host application (for example the TUI), so it is discarded; reporting
+* every byte as written keeps libc from retrying. With `determinism`, the clock
+* and random source are pinned as well.
+*/
+function wasiOverrides(determinism) {
+	return (memory) => {
+		const overrides = { fd_write(_fd, iovsPtr, iovsLen, nwrittenPtr) {
+			const view = new DataView(memory.buffer);
+			let written = 0;
+			for (let i = 0; i < iovsLen; i++) written += view.getUint32(iovsPtr + i * 8 + 4, true);
+			view.setUint32(nwrittenPtr, written, true);
+			return ESUCCESS;
+		} };
+		if (!determinism) return overrides;
+		const nowNs = BigInt(Math.trunc(determinism.nowMs)) * 1000000n;
+		let state = determinism.seed >>> 0 || 2654435769;
+		overrides.clock_time_get = (_clockId, _precision, resultPtr) => {
+			new DataView(memory.buffer).setBigUint64(resultPtr, nowNs, true);
+			return ESUCCESS;
+		};
+		overrides.random_get = (bufPtr, bufLen) => {
+			const bytes = new Uint8Array(memory.buffer, bufPtr, bufLen);
+			for (let i = 0; i < bufLen; i++) {
+				state ^= state << 13;
+				state ^= state >>> 17;
+				state ^= state << 5;
+				state >>>= 0;
+				bytes[i] = state & 255;
+			}
+			return ESUCCESS;
+		};
+		return overrides;
+	};
+}
+function describeException(error) {
+	const head = error.message ? `${error.name}: ${error.message}` : error.name;
+	const stack = error.stack?.trimEnd();
+	return JSON.stringify({
+		name: error.name,
+		message: error.message,
+		stack: stack ? `${head}\n${stack}` : head
+	});
+}
+async function main(data) {
+	const interrupt = new Int32Array(data.interrupt);
+	const vm = await QuickJS.create({
+		wasm: data.wasm,
+		memoryLimit: data.memoryLimitBytes,
+		maxStackSize: MAX_STACK_SIZE,
+		interruptHandler: () => Atomics.load(interrupt, 0) !== 0,
+		wasi: wasiOverrides(data.determinism)
+	});
+	const bridge = vm.newFunction("bridge", (kind, a, b, c) => {
+		switch (kind.toString()) {
+			case "call":
+			case "global":
+				post({
+					type: "call",
+					id: a.toNumber(),
+					target: kind.toString() === "call" ? "tool" : "global",
+					name: b.toString(),
+					args: c === void 0 || c.isUndefined ? void 0 : c.toString()
+				});
+				break;
+			case "output":
+				post({
+					type: "output",
+					item: a.toString() === "image" ? {
+						type: "image",
+						data: b.toString(),
+						mimeType: c.toString()
+					} : a.toString() === "console" ? {
+						type: "text",
+						text: b.toString(),
+						console: true
+					} : {
+						type: "text",
+						text: b.toString()
+					}
+				});
+				break;
+			case "done": if (a.toBoolean()) post({
+				type: "done",
+				ok: true,
+				value: b === void 0 || b.isUndefined ? void 0 : b.toString(),
+				writes: c.toString()
+			});
+			else post({
+				type: "done",
+				ok: false,
+				error: b.toString()
+			});
+		}
+		return vm.undefined;
+	});
+	const api = vm.withScope((scope) => scope.escape(vm.callFunction(vm.evalCode(PRELUDE_SOURCE, "codemode-prelude.js"), vm.undefined, bridge, vm.newString(JSON.stringify(data.tools)), vm.newString(JSON.stringify(data.globals)), vm.newString(JSON.stringify(data.store)))));
+	const settle = api.getProp("settle");
+	const run = api.getProp("run");
+	const stalled = api.getProp("stalled");
+	/** Run queued jobs, then fail a script that waits on nothing that can ever resume it. */
+	const drain = () => {
+		vm.executePendingJobs();
+		vm.callFunction(stalled, api).dispose();
+	};
+	parentPort?.on("message", (message) => {
+		if (!isHostToWorkerMessage(message)) return;
+		try {
+			vm.withScope(() => {
+				vm.callFunction(settle, api, vm.newNumber(message.id), message.ok ? vm.true : vm.false, message.payload === void 0 ? vm.undefined : vm.newString(message.payload));
+			});
+			drain();
+		} catch (error) {
+			crash(error);
+		}
+	});
+	let fn;
+	try {
+		fn = vm.evalCode(`(async (tools, console) => {${data.code}\n})`, "codemode.js");
+	} catch (error) {
+		if (!(error instanceof JSException)) throw error;
+		post({
+			type: "done",
+			ok: false,
+			error: describeException(error)
+		});
+		return;
+	}
+	vm.callFunction(run, api, fn).dispose();
+	fn.dispose();
+	drain();
+}
+if (parentPort) main(workerData).catch(crash);
+//#endregion
+export {};
+
+//# sourceMappingURL=codemode-worker.js.map

package/dist/codemode-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codemode-worker.js","names":[],"sources":["../src/codemode/runtime/worker.ts"],"sourcesContent":["/**\n * Worker thread entry. One worker runs one script inside a fresh QuickJS VM\n * (a separate wasm instance), relays tool calls and output to the host, and\n * reports the result. The host terminates the worker when the script settles,\n * times out, or is aborted; the worker exists so that a spinning script never\n * blocks the host thread.\n *\n * Importing this module starts the worker. Bundled hosts (a Bun compiled\n * executable, a re-bundled zidane) add this file as a separate entrypoint and\n * pass its URL or embedded-module specifier as `workerUrl`.\n */\nimport type { JSValueHandle } from 'quickjs-wasi'\nimport type { CodemodeDeterminism } from '../types'\nimport type { WorkerData, WorkerToHostMessage } from './protocol'\nimport { parentPort, workerData } from 'node:worker_threads'\nimport { JSException, MAX_STACK_SIZE, QuickJS } from 'quickjs-wasi'\nimport { PRELUDE_SOURCE } from './prelude'\nimport { isHostToWorkerMessage } from './protocol'\n\nfunction post(message: WorkerToHostMessage): void {\n  parentPort?.postMessage(message)\n}\n\nfunction crash(error: unknown): void {\n  post({ type: 'crash', message: error instanceof Error ? `${error.name}: ${error.message}` : String(error) })\n}\n\n/** WASI `errno` for success. */\nconst ESUCCESS = 0\n\n/**\n * WASI overrides. QuickJS writes engine diagnostics to fd 1 and 2, which the\n * default shim forwards to the host's stdout and stderr. That output belongs to\n * the host application (for example the TUI), so it is discarded; reporting\n * every byte as written keeps libc from retrying. With `determinism`, the clock\n * and random source are pinned as well.\n */\nfunction wasiOverrides(determinism: CodemodeDeterminism | undefined) {\n  return (memory: { readonly buffer: ArrayBufferLike }) => {\n    const overrides: Record<string, (...args: never[]) => number> = {\n      fd_write(_fd: number, iovsPtr: number, iovsLen: number, nwrittenPtr: number): number {\n        const view = new DataView(memory.buffer)\n        let written = 0\n        for (let i = 0; i < iovsLen; i++)\n          written += view.getUint32(iovsPtr + i * 8 + 4, true)\n        view.setUint32(nwrittenPtr, written, true)\n        return ESUCCESS\n      },\n    }\n    if (!determinism)\n      return overrides\n    const nowNs = BigInt(Math.trunc(determinism.nowMs)) * 1_000_000n\n    // xorshift32; a zero state would stay zero.\n    let state = (determinism.seed >>> 0) || 0x9E3779B9\n    overrides.clock_time_get = (_clockId: number, _precision: bigint, resultPtr: number): number => {\n      new DataView(memory.buffer).setBigUint64(resultPtr, nowNs, true)\n      return ESUCCESS\n    }\n    overrides.random_get = (bufPtr: number, bufLen: number): number => {\n      const bytes = new Uint8Array(memory.buffer, bufPtr, bufLen)\n      for (let i = 0; i < bufLen; i++) {\n        state ^= state << 13\n        state ^= state >>> 17\n        state ^= state << 5\n        state >>>= 0\n        bytes[i] = state & 0xFF\n      }\n      return ESUCCESS\n    }\n    return overrides\n  }\n}\n\nfunction describeException(error: JSException): string {\n  const head = error.message ? `${error.name}: ${error.message}` : error.name\n  const stack = error.stack?.trimEnd()\n  return JSON.stringify({ name: error.name, message: error.message, stack: stack ? `${head}\\n${stack}` : head })\n}\n\nasync function main(data: WorkerData): Promise<void> {\n  const interrupt = new Int32Array(data.interrupt)\n  const vm = await QuickJS.create({\n    wasm: data.wasm as WebAssembly.Module,\n    memoryLimit: data.memoryLimitBytes,\n    // Without a guard, deep recursion overflows the wasm stack and traps instead of throwing a\n    // catchable RangeError.\n    maxStackSize: MAX_STACK_SIZE,\n    interruptHandler: () => Atomics.load(interrupt, 0) !== 0,\n    wasi: wasiOverrides(data.determinism),\n  })\n\n  // Called from the prelude with primitives only.\n  const bridge = vm.newFunction('bridge', (kind, a, b, c) => {\n    switch (kind.toString()) {\n      case 'call':\n      case 'global':\n        post({\n          type: 'call',\n          id: a.toNumber(),\n          target: kind.toString() === 'call' ? 'tool' : 'global',\n          name: b.toString(),\n          args: c === undefined || c.isUndefined ? undefined : c.toString(),\n        })\n        break\n      case 'output':\n        post({\n          type: 'output',\n          item:\n            a.toString() === 'image'\n              ? { type: 'image', data: b.toString(), mimeType: c.toString() }\n              : a.toString() === 'console'\n                ? { type: 'text', text: b.toString(), console: true }\n                : { type: 'text', text: b.toString() },\n        })\n        break\n      case 'done':\n        if (a.toBoolean()) {\n          post({\n            type: 'done',\n            ok: true,\n            value: b === undefined || b.isUndefined ? undefined : b.toString(),\n            writes: c.toString(),\n          })\n        }\n        else {\n          post({ type: 'done', ok: false, error: b.toString() })\n        }\n        break\n    }\n    return vm.undefined\n  })\n\n  // The VM lives until the host terminates the worker, so these handles are never disposed.\n  const api = vm.withScope(scope =>\n    scope.escape(\n      vm.callFunction(\n        vm.evalCode(PRELUDE_SOURCE, 'codemode-prelude.js'),\n        vm.undefined,\n        bridge,\n        vm.newString(JSON.stringify(data.tools)),\n        vm.newString(JSON.stringify(data.globals)),\n        vm.newString(JSON.stringify(data.store)),\n      ),\n    ),\n  )\n  const settle = api.getProp('settle')\n  const run = api.getProp('run')\n  const stalled = api.getProp('stalled')\n  /** Run queued jobs, then fail a script that waits on nothing that can ever resume it. */\n  const drain = () => {\n    vm.executePendingJobs()\n    vm.callFunction(stalled, api).dispose()\n  }\n\n  parentPort?.on('message', (message: unknown) => {\n    if (!isHostToWorkerMessage(message))\n      return\n    try {\n      vm.withScope(() => {\n        vm.callFunction(\n          settle,\n          api,\n          vm.newNumber(message.id),\n          message.ok ? vm.true : vm.false,\n          message.payload === undefined ? vm.undefined : vm.newString(message.payload),\n        )\n      })\n      drain()\n    }\n    catch (error) {\n      crash(error)\n    }\n  })\n\n  // The prefix shares the first line with the script so reported line numbers\n  // match the script as written.\n  let fn: JSValueHandle\n  try {\n    fn = vm.evalCode(`(async (tools, console) => {${data.code}\\n})`, 'codemode.js')\n  }\n  catch (error) {\n    if (!(error instanceof JSException))\n      throw error\n    post({ type: 'done', ok: false, error: describeException(error) })\n    return\n  }\n  vm.callFunction(run, api, fn).dispose()\n  fn.dispose()\n  drain()\n}\n\nif (parentPort)\n  main(workerData as WorkerData).catch(crash)\n"],"mappings":"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"}

package/dist/codemode.d.ts

@@ -0,0 +1,352 @@
+//#region src/codemode/wasm.d.ts
+/**
+ * A compiled `WebAssembly.Module` of `quickjs-wasi/quickjs.wasm`. Typed opaquely so callers don't
+ * need the DOM lib for the WebAssembly globals.
+ */
+type CodemodeWasmModule = object;
+/**
+ * Read and compile the QuickJS wasm once per path. `path` defaults to the file in the installed
+ * `quickjs-wasi` package (an optional peer dependency); pass it when the file lives elsewhere, for
+ * example embedded in a Bun compiled executable. A failed load is retried on the next call.
+ */
+declare function loadQuickJSWasm(path?: string): Promise<CodemodeWasmModule>;
+//#endregion
+//#region src/codemode/types.d.ts
+interface CodemodeToolContext {
+  /**
+   * Aborted when the script finishes (including unawaited calls), the
+   * execution times out, the caller aborts, or the sandbox is closed.
+   */
+  signal: AbortSignal;
+  /**
+   * 1-based position of this call in the order the script issued it, shared
+   * by tools and globals. The VM is single-threaded and has no timers, so for
+   * a given script and given results the order is the same on every run:
+   * durable adapters can key journal entries on it.
+   */
+  seq: number;
+}
+/** A JSON Schema document. Only used to render declarations; values are not validated against it. */
+type CodemodeJsonSchema = {
+  [key: string]: unknown;
+} | boolean;
+interface CodemodeTool {
+  /**
+   * The script calls tools as `tools.<id>(args)`, where `<id>` is the name with characters that
+   * are not valid in identifiers replaced by `_` (see `toCodemodeIdentifier`), and also as
+   * `tools["<name>"](args)`. Globals are called as `<name>(args)` and must be identifiers, or
+   * `<namespace>.<member>`, which groups them into a frozen namespace object.
+   */
+  name: string;
+  /** Shown as a doc comment in `renderDeclarations`, and listed in `ALL_TOOLS` for tools. */
+  description?: string;
+  /** Schema of the single argument. Rendered as the parameter type; `unknown` when omitted. */
+  inputSchema?: CodemodeJsonSchema;
+  /** Schema of the resolved value. Rendered as the promise type; `unknown` when omitted. */
+  outputSchema?: CodemodeJsonSchema;
+  /** Globals only: `execute` receives all call arguments as an array instead of the first one. */
+  spread?: boolean;
+  /**
+   * Globals only: TypeScript parameter list and return type for `renderDeclarations`, for
+   * example `(type: string, id?: string): Promise<Model[]>`. Replaces the rendering from the schemas.
+   */
+  signature?: string;
+  /**
+   * `args` is whatever the script passed, after a JSON round trip. The return
+   * value must be JSON-serializable; a thrown error surfaces in the script as
+   * an `Error` with the same message.
+   */
+  execute: (args: unknown, context: CodemodeToolContext) => Promise<unknown> | unknown;
+}
+/**
+ * One item of the script's output, in the order the script produced it: `text()` and `console.*`
+ * produce text items, with `console: true` for `console.*`, and `image()` image items. `data` is base64.
+ */
+type CodemodeOutputItem = {
+  type: 'text';
+  text: string;
+  console?: true;
+} | {
+  type: 'image';
+  data: string;
+  mimeType: string;
+};
+type CodemodeCallStatus = 'ok' | 'error' | 'cancelled';
+interface CodemodeCall {
+  name: string;
+  /** Same as {@link CodemodeToolContext.seq} for this call. */
+  seq: number;
+  status: CodemodeCallStatus;
+  durationMs: number;
+}
+type CodemodeErrorKind = 'script' |
+/** The overall deadline expired. The worker was terminated. */
+'timeout' |
+/** The caller's signal fired or the sandbox was closed. The worker was terminated. */
+'aborted' |
+/** The worker or VM failed outside the script's control (for example a wasm trap or a missing worker file). */
+'sandbox';
+interface CodemodeError {
+  kind: CodemodeErrorKind;
+  name?: string;
+  message: string;
+  stack?: string;
+}
+/** Keys the script changed with `store()`. Only successful executions report writes. */
+interface CodemodeStoreWrites {
+  set: Record<string, unknown>;
+  /** Keys stored as `undefined`. */
+  delete: string[];
+}
+/** `output` is kept for failed executions too, up to the failure. `exit()` completes with `value: undefined`. */
+type CodemodeResult = {
+  ok: true;
+  value: unknown;
+  output: CodemodeOutputItem[];
+  calls: CodemodeCall[];
+  storeWrites: CodemodeStoreWrites;
+} | {
+  ok: false;
+  error: CodemodeError;
+  output: CodemodeOutputItem[];
+  calls: CodemodeCall[];
+};
+/**
+ * Pins the VM's only nondeterministic inputs, the WASI clock and random
+ * source. `Date.now()` returns `nowMs` for the whole run and `Math.random()`
+ * (seeded from the clock by QuickJS) plus WASI `random_get` derive from
+ * `seed`. With these set, a script that sees the same tool results takes the
+ * same path, which is what durable replay needs.
+ */
+interface CodemodeDeterminism {
+  nowMs: number;
+  seed: number;
+}
+interface CodemodeSandboxOptions {
+  tools?: CodemodeTool[];
+  /**
+   * Functions exposed as top-level identifiers instead of on `tools`, for host helpers such as
+   * attaching an image to the result. They behave like tools (JSON round trip, promise result)
+   * but are not recorded in `result.calls`. Names must be identifiers and may not shadow the
+   * built-in globals (`tools`, `ALL_TOOLS`, `console`, `text`, `image`, `exit`, `store`, `load`).
+   */
+  globals?: CodemodeTool[];
+  /**
+   * Overall deadline per execution, including time spent in tools. `Infinity` disables the
+   * deadline; the execution then only ends when the script settles or is aborted.
+   * Default: 300000.
+   */
+  timeoutMs?: number;
+  /**
+   * Maximum memory the QuickJS VM may allocate. Allocations beyond it fail inside the script as
+   * `InternalError: out of memory`. Default: no limit beyond wasm32's 4 GiB address space.
+   */
+  memoryLimitBytes?: number;
+  /**
+   * Compiled `quickjs-wasi/quickjs.wasm`, usually from `loadQuickJSWasm`. Default: the file in
+   * the installed `quickjs-wasi` package. Pass it when that file is not on disk, for example in a
+   * Bun compiled executable.
+   */
+  wasm?: CodemodeWasmModule | Promise<CodemodeWasmModule>;
+  /**
+   * Worker entry (`src/codemode/runtime/worker.ts`, `dist/codemode-worker.js`). Default: the
+   * sibling of this module. Pass it when zidane is re-bundled. Bun compiled executables need
+   * the relative string specifier of an embedded build entrypoint; other hosts usually use a URL.
+   */
+  workerUrl?: string | URL;
+}
+interface CodemodeExecuteOptions {
+  signal?: AbortSignal;
+  /** Overrides the sandbox default for this execution. */
+  timeoutMs?: number;
+  /**
+   * Values the script reads with `load(key)`. Must be JSON-serializable. The script's own
+   * `store()` calls come back as `result.storeWrites`; persisting them is up to the caller.
+   */
+  store?: Readonly<Record<string, unknown>>;
+  /** Pin the clock and random source for this execution. See {@link CodemodeDeterminism}. */
+  determinism?: CodemodeDeterminism;
+}
+//#endregion
+//#region src/codemode/identifier.d.ts
+/**
+ * The identifier a script uses for a tool: characters that are not valid in a JavaScript
+ * identifier become `_`. `mcp__docs__search` stays as is, `my-tool` becomes `my_tool`.
+ */
+declare function toCodemodeIdentifier(name: string): string;
+//#endregion
+//#region src/codemode/declarations.d.ts
+/** Largest rendered input type, in characters, before it becomes `unknown`. */
+declare const DEFAULT_INPUT_SCHEMA_MAX_CHARS = 16000;
+/**
+ * TypeScript types for MCP results, from the MCP `CallToolResult` schema, so `CallToolResult<T>`
+ * declarations can refer to them.
+ */
+declare const MCP_TYPESCRIPT_PREAMBLE = "type Role = \"user\" | \"assistant\";\ntype MetaObject = Record<string, unknown>;\ntype Annotations = {\n  audience?: Role[];\n  priority?: number;\n  lastModified?: string;\n};\ntype Icon = {\n  src: string;\n  mimeType?: string;\n  sizes?: string[];\n  theme?: \"light\" | \"dark\";\n};\ntype TextResourceContents = {\n  uri: string;\n  mimeType?: string;\n  _meta?: MetaObject;\n  text: string;\n};\ntype BlobResourceContents = {\n  uri: string;\n  mimeType?: string;\n  _meta?: MetaObject;\n  blob: string;\n};\ntype TextContent = {\n  type: \"text\";\n  text: string;\n  annotations?: Annotations;\n  _meta?: MetaObject;\n};\ntype ImageContent = {\n  type: \"image\";\n  data: string;\n  mimeType: string;\n  annotations?: Annotations;\n  _meta?: MetaObject;\n};\ntype AudioContent = {\n  type: \"audio\";\n  data: string;\n  mimeType: string;\n  annotations?: Annotations;\n  _meta?: MetaObject;\n};\ntype ResourceLink = {\n  icons?: Icon[];\n  name: string;\n  title?: string;\n  uri: string;\n  description?: string;\n  mimeType?: string;\n  annotations?: Annotations;\n  size?: number;\n  _meta?: MetaObject;\n  type: \"resource_link\";\n};\ntype EmbeddedResource = {\n  type: \"resource\";\n  resource: TextResourceContents | BlobResourceContents;\n  annotations?: Annotations;\n  _meta?: MetaObject;\n};\ntype ContentBlock =\n  | TextContent\n  | ImageContent\n  | AudioContent\n  | ResourceLink\n  | EmbeddedResource;\ntype CallToolResult<TStructured = { [key: string]: unknown }> = {\n  _meta?: MetaObject;\n  content: ContentBlock[];\n  isError?: boolean;\n  structuredContent?: TStructured;\n  [key: string]: unknown;\n};";
+interface RenderDeclarationsOptions {
+  tools?: readonly CodemodeTool[];
+  globals?: readonly CodemodeTool[];
+}
+/**
+ * Render TypeScript declarations for the script-visible API. Tools become members of
+ * `declare const tools`, globals become `declare function` statements, and `ns.member` globals
+ * members of `declare const ns`. Descriptions become doc comments; schemas become types.
+ */
+declare function renderDeclarations(options: RenderDeclarationsOptions): string;
+/**
+ * One tool as a member of the `tools` object: `name(args: T): Promise<R>;` with the
+ * name as the identifier scripts use. Input types longer than `inputMaxChars` render as `unknown`.
+ * Tools whose output schema is an MCP `CallToolResult` render as `Promise<CallToolResult<T>>`,
+ * which needs {@link MCP_TYPESCRIPT_PREAMBLE}.
+ */
+declare function renderToolSignature(tool: Pick<CodemodeTool, 'name' | 'inputSchema' | 'outputSchema'>, options?: {
+  inputMaxChars?: number;
+}): string;
+/**
+ * A tool's sample: the description followed by the tool's declaration. Used for tool
+ * listings and `ALL_TOOLS` entries.
+ */
+declare function renderToolSample(tool: Pick<CodemodeTool, 'name' | 'description' | 'inputSchema' | 'outputSchema'>, options?: {
+  inputMaxChars?: number;
+}): string;
+/**
+ * The `structuredContent` schema of an MCP `CallToolResult` output schema (detected by a
+ * `content` array of objects, boolean `isError`, and object `_meta`), `true` when it declares none, or
+ * `undefined` when the schema is not a `CallToolResult`.
+ */
+declare function mcpStructuredContentSchema(schema: CodemodeJsonSchema | undefined): CodemodeJsonSchema | undefined;
+/**
+ * The type a tool call resolves to: `CallToolResult<T>` for MCP output schemas (needs
+ * {@link MCP_TYPESCRIPT_PREAMBLE}), the schema's type otherwise, and `unknown` without a schema.
+ */
+declare function renderToolOutputType(schema: CodemodeJsonSchema | undefined): string;
+/**
+ * Convert a JSON Schema to a TypeScript type expression: objects on one line (`{ a: string; b?: number; }`) with properties sorted by name,
+ * or one property per line with `//` comments when a property has a description; `Array<T>` for
+ * arrays. Local references (`#/$defs/...`, `#/definitions/...`) resolve against `schema`;
+ * recursive and remote references render as `unknown`. A result longer than `maxChars` renders as
+ * `unknown`.
+ */
+declare function schemaToType(schema: CodemodeJsonSchema, options?: {
+  maxChars?: number;
+}): string;
+//#endregion
+//#region src/codemode/runtime/host.d.ts
+/**
+ * Runs JavaScript in a QuickJS VM (a separate wasm instance) inside a worker
+ * thread. The script sees `tools.<name>(args)` for every registered tool, `ALL_TOOLS`,
+ * the output helpers `text`, `image`, `exit`, and `console.*`, `store`/`load`, and the
+ * configured globals; nothing else (no timers, `fetch`, `process`, `require`, modules).
+ *
+ * Each `execute()` gets its own worker and VM; the sandbox only holds the tool
+ * table and defaults. `close()` aborts in-flight executions.
+ */
+declare class CodemodeSandbox {
+  private readonly toolsByName;
+  private readonly globalsByName;
+  private readonly timeoutMs;
+  private readonly memoryLimitBytes;
+  private readonly wasm;
+  private readonly workerUrl;
+  private readonly running;
+  private closed;
+  constructor(options?: CodemodeSandboxOptions);
+  /** Throws if a tool with the same name is already registered. */
+  registerTool(tool: CodemodeTool): void;
+  unregisterTool(name: string): boolean;
+  get tools(): CodemodeTool[];
+  get globals(): CodemodeTool[];
+  /**
+   * `code` is an async function body: `return` and top-level `await` work.
+   * Never rejects for script failures; those come back as `{ ok: false }`.
+   * The script can use `store(key, value)` and `load(key)` on `options.store`.
+   */
+  execute(code: string, options?: CodemodeExecuteOptions): Promise<CodemodeResult>;
+  /** Aborts in-flight executions (they resolve with `kind: "aborted"`) and rejects new ones. */
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/codemode/runtime/prelude.d.ts
+/**
+ * JavaScript evaluated inside the QuickJS VM before the script runs.
+ *
+ * The VM is its own wasm instance, so nothing here guards a realm boundary.
+ * The prelude keeps the host bridge in a closure so the script cannot call it
+ * directly, and builds `tools`, `ALL_TOOLS`, the output helpers (`text`, `image`,
+ * `exit`, `console`), and globals on top of it. Tool arguments and results cross
+ * as JSON strings and are parsed on this side.
+ *
+ * Output helpers: `text(value)` appends a text item (non-strings are
+ * JSON-stringified), `image(urlOrItem)` appends an image from a base64 `data:` URL, an
+ * `{ image_url }` object, or an MCP `ImageContent` block, and `exit()` ends the script
+ * successfully. `console.*` appends text items marked as console output.
+ *
+ * `store(key, value)` and `load(key)` are synchronous: they work on a snapshot of
+ * JSON text passed in as `storeJson`, and the keys the script wrote are reported
+ * with a successful "done".
+ *
+ * Evaluates to a function `(bridge, toolsJson, globalsJson, storeJson) => { settle, run, stalled }`.
+ * `toolsJson` lists `{ name, jsName, description }`: `tools[jsName]` and `tools[name]` call the
+ * tool, and `ALL_TOOLS` lists `{ name: jsName, description }`.
+ * `stalled()` reports a script that has not finished while no host call is pending: with no timers
+ * or I/O in the VM, nothing can ever resume it.
+ * `globalsJson` lists `{ name, spread }`; `a.b` names are grouped into a frozen `a` object.
+ * `bridge(kind, a, b, c)` with kind "call" or "global" (id, name, argsJson),
+ * "output" ("text" or "console", text) or ("image", data, mimeType), or "done" (ok, valueJsonOrErrorJson, writesJson).
+ *
+ * Calls get ids from one counter shared by tools and globals, in issue order: the host exposes
+ * them as `CodemodeToolContext.seq`.
+ *
+ * Before anything else the prelude freezes the built-ins and makes the built-in globals read-only.
+ * The prelude shares them with the script, so a script that patched one (for example
+ * `Array.prototype.toJSON`) could otherwise corrupt what the prelude reports to the host.
+ */
+declare const MAX_STORE_VALUE_CHARS: number;
+declare const MAX_STORE_TOTAL_CHARS: number;
+/**
+ * Output one script may produce with `text()`, `image()`, and `console.*`: characters of text and
+ * base64 image data, and items. The host keeps all output until the script ends, so without a
+ * limit a script that prints in a loop grows the host's memory until it crashes. The item limit
+ * covers loops that print empty strings.
+ */
+declare const MAX_OUTPUT_CHARS: number;
+declare const MAX_OUTPUT_ITEMS = 100000;
+//#endregion
+//#region src/codemode/source.d.ts
+/**
+ * Codemode source format: JavaScript, optionally preceded by one options line.
+ *
+ * ```js
+ * // @options: {"max_output_tokens": 2000, "timeout_ms": 30000}
+ * const text = await tools.read_file({ path: "package.json" });
+ * text(JSON.parse(text).name);
+ * ```
+ */
+declare const CODEMODE_OPTIONS_PREFIX = "// @options:";
+/**
+ * Lark grammar for providers with grammar-constrained tool input. It only fixes the shape of the
+ * options line; the options JSON and the code are checked by {@link parseCodemodeSource}.
+ */
+declare const CODEMODE_SOURCE_GRAMMAR: string;
+interface CodemodeSourceOptions {
+  /** Token budget for the script's output. */
+  maxOutputTokens?: number;
+  /** Hard deadline for the whole script in milliseconds, including tool calls. */
+  timeoutMs?: number;
+}
+interface ParsedCodemodeSource {
+  /** The script with the options line replaced by an empty line, so line numbers are unchanged. */
+  code: string;
+  options: CodemodeSourceOptions;
+}
+declare class CodemodeSourceError extends Error {
+  constructor(message: string);
+}
+/**
+ * Split an optional first-line `// @options: {...}` from the script. Throws
+ * {@link CodemodeSourceError} for empty input and invalid options.
+ */
+declare function parseCodemodeSource(input: string): ParsedCodemodeSource;
+//#endregion
+export { CODEMODE_OPTIONS_PREFIX, CODEMODE_SOURCE_GRAMMAR, type CodemodeCall, type CodemodeCallStatus, type CodemodeDeterminism, type CodemodeError, type CodemodeErrorKind, type CodemodeExecuteOptions, type CodemodeJsonSchema, type CodemodeOutputItem, type CodemodeResult, CodemodeSandbox, type CodemodeSandboxOptions, CodemodeSourceError, type CodemodeSourceOptions, type CodemodeStoreWrites, type CodemodeTool, type CodemodeToolContext, type CodemodeWasmModule, DEFAULT_INPUT_SCHEMA_MAX_CHARS, MAX_OUTPUT_CHARS, MAX_OUTPUT_ITEMS, MAX_STORE_TOTAL_CHARS, MAX_STORE_VALUE_CHARS, MCP_TYPESCRIPT_PREAMBLE, type ParsedCodemodeSource, type RenderDeclarationsOptions, loadQuickJSWasm, mcpStructuredContentSchema, parseCodemodeSource, renderDeclarations, renderToolOutputType, renderToolSample, renderToolSignature, schemaToType, toCodemodeIdentifier };
+//# sourceMappingURL=codemode.d.ts.map

package/dist/codemode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codemode.d.ts","names":[],"sources":["../src/codemode/wasm.ts","../src/codemode/types.ts","../src/codemode/identifier.ts","../src/codemode/declarations.ts","../src/codemode/runtime/host.ts","../src/codemode/runtime/prelude.ts","../src/codemode/source.ts"],"mappings":";;;;;KAOY;;;;;;iBAaI,gBAAgB,gBAAgB,QAAQ;;;UClBvC;;;;;EAKf,QAAQ;;;;;;;EAOR;;;KAIU;GAAwB;;UAEnB;;;;;;;EAOf;;EAEA;;EAEA,cAAc;;EAEd,eAAe;;EAEf;;;;;EAKA;;;;;;EAMA,UAAU,eAAe,SAAS,wBAAwB;;;;;;KAOhD;EACJ;EAAc;EAAc;;EAC5B;EAAe;EAAc;;KAEzB;UAEK;EACf;;EAEA;EACA,QAAQ;EACR;;KAGU;;;;;;;UAUK;EACf,MAAM;EACN;EACA;EACA;;;UAIe;EACf,KAAK;;EAEL;;;KAIU;EAER;EACA;EACA,QAAQ;EACR,OAAO;EACP,aAAa;;EAEX;EAAW,OAAO;EAAe,QAAQ;EAAsB,OAAO;;;;;;;;;UAS3D;EACf;EACA;;UAGe;EACf,QAAQ;;;;;;;EAOR,UAAU;;;;;;EAMV;;;;;EAKA;;;;;;EAMA,OAAO,qBAAqB,QAAQ;;;;;;EAMpC,qBAAqB;;UAGN;EACf,SAAS;;EAET;;;;;EAKA,QAAQ,SAAS;;EAEjB,cAAc;;;;;;;;iBC1JA,qBAAqB;;;;cCIxB;;;;;cAQA;UA6EI;EACf,iBAAiB;EACjB,mBAAmB;;;;;;;iBAQL,mBAAmB,SAAS;;;;;;;iBAkC5B,oBACd,MAAM,KAAK,wDACX;EAAW;;;;;;iBAaG,iBACd,MAAM,KAAK,wEACX;EAAW;;;;;;;iBAWG,2BAA2B,QAAQ,iCAAiC;;;;;iBAgBpE,qBAAqB,QAAQ;;;;;;;;iBAkD7B,aAAa,QAAQ,oBAAoB;EAAW;;;;;;;;;;;;;cC8HvD;mBACM;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;UACT;EAEI,YAAA,UAAS;;EAyBrB,aAAa,MAAM;EAMnB,eAAe;MAIX,SAAS;MAIT,WAAW;;;;;;EASf,QAAQ,cAAc,UAAS,yBAA8B,QAAQ;;EAoB/D,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC/YJ;cACA;;;;;;;cAOA;cACA;;;;;;;;;;;;cCnCA;;;;;cAWA;UAUI;;EAEf;;EAEA;;UAGe;;EAEf;EACA,SAAS;;cAGE,4BAA4B;EAC3B,YAAA;;;;;;iBAgDE,oBAAoB,gBAAgB"}

package/dist/codemode.js

@@ -0,0 +1,5 @@
+import { a as DEFAULT_INPUT_SCHEMA_MAX_CHARS, c as renderDeclarations, d as renderToolSignature, f as schemaToType, i as parseCodemodeSource, l as renderToolOutputType, n as CODEMODE_SOURCE_GRAMMAR, o as MCP_TYPESCRIPT_PREAMBLE, p as toCodemodeIdentifier, r as CodemodeSourceError, s as mcpStructuredContentSchema, t as CODEMODE_OPTIONS_PREFIX, u as renderToolSample } from "./source-mPExaUm8.js";
+import { t as loadQuickJSWasm } from "./wasm-BVT-j5cl.js";
+import { t as CodemodeSandbox } from "./host-D7NrI03V.js";
+import { i as MAX_STORE_VALUE_CHARS, n as MAX_OUTPUT_ITEMS, r as MAX_STORE_TOTAL_CHARS, t as MAX_OUTPUT_CHARS } from "./prelude-Cxo4t74B.js";
+export { CODEMODE_OPTIONS_PREFIX, CODEMODE_SOURCE_GRAMMAR, CodemodeSandbox, CodemodeSourceError, DEFAULT_INPUT_SCHEMA_MAX_CHARS, MAX_OUTPUT_CHARS, MAX_OUTPUT_ITEMS, MAX_STORE_TOTAL_CHARS, MAX_STORE_VALUE_CHARS, MCP_TYPESCRIPT_PREAMBLE, loadQuickJSWasm, mcpStructuredContentSchema, parseCodemodeSource, renderDeclarations, renderToolOutputType, renderToolSample, renderToolSignature, schemaToType, toCodemodeIdentifier };

package/dist/connection-Dr-Js4yZ.d.ts

@@ -0,0 +1,28 @@
+//#region src/chat/hosts/connection.d.ts
+/** This computer's key in every host directory (the in-process host, the embedded one, or the daemon). */
+declare const LOCAL_HOST_KEY = "local";
+/** This computer's label in lists and pickers. */
+declare const LOCAL_HOST_NAME = "This computer";
+/**
+ * `auth-refused`: the server turned the token down (401/403); `identity`: a
+ * different server answers at a saved host's URL. Neither retries until
+ * something changes.
+ */
+type HostConnectionStatus = 'connecting' | 'connected' | 'reconnecting' | 'offline' | 'auth-refused' | 'identity';
+/**
+ * A saved host's URL answered with another host id (reinstalled, or the
+ * name now points elsewhere). The connection is closed before anything is
+ * read from it, and nothing is recorded under the saved id.
+ */
+declare class HostIdentityError extends Error {
+  readonly url: string;
+  readonly answeredBy?: string | undefined;
+  constructor(url: string, answeredBy?: string | undefined);
+}
+/** JSON-RPC "method not found": the host predates an additive method. */
+declare const METHOD_NOT_FOUND: number;
+/** The host predates the method (`models.list`, `catalog.*`, …): callers degrade, never fail. */
+declare function isMethodNotFound(err: unknown): boolean;
+//#endregion
+export { METHOD_NOT_FOUND as a, LOCAL_HOST_NAME as i, HostIdentityError as n, isMethodNotFound as o, LOCAL_HOST_KEY as r, HostConnectionStatus as t };
+//# sourceMappingURL=connection-Dr-Js4yZ.d.ts.map

package/dist/connection-Dr-Js4yZ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-Dr-Js4yZ.d.ts","names":[],"sources":["../src/chat/hosts/connection.ts"],"mappings":";;cAQa;;cAGA;;;;;;KAOD;;;;;;cAOC,0BAA0B;WAChB;WAAsB;EAAtB,YAAA,aAAsB;;;cAOhC;;iBAGG,iBAAiB"}