@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/dist/execute-71ysgv35.js

@@ -0,0 +1,965 @@
+import {
+  Bm25Ranker,
+  CODEMODE_STORE_ENTRY_TYPE,
+  DEFAULT_TOOL_SEARCH_LIMIT,
+  MODEL_GLOBAL_DECLARATIONS,
+  combineUsage,
+  createToolSearchDocument,
+  getCodemodeCallableTools,
+  parseCodemodeSource,
+  renderToolSample,
+  toCodemodeDeclaration,
+  toCodemodeIdentifier
+} from "./cli-qvnnx4ct.js";
+import {
+  getCodemodeWorkerUrl,
+  getQuickJSWasmPath
+} from "./cli-hj65wsts.js";
+import"./cli-5bfdm1ah.js";
+import"./cli-0m7wct0d.js";
+import"./cli-rb9m6rpe.js";
+import"./cli-pqetb83f.js";
+import"./cli-bc05qbss.js";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/execute.js
+import { randomBytes } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// node_modules/@earendil-works/pi-codemode/dist/runtime/host.js
+import { Worker } from "node:worker_threads";
+
+// node_modules/@earendil-works/pi-codemode/dist/wasm.js
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+var modules = new Map;
+function loadQuickJSWasm(path) {
+  const resolved = path ?? createRequire(import.meta.url).resolve("quickjs-wasi/quickjs.wasm");
+  let module = modules.get(resolved);
+  if (!module) {
+    const { WebAssembly } = globalThis;
+    module = readFile(resolved).then((bytes) => WebAssembly.compile(bytes)).catch((error) => {
+      modules.delete(resolved);
+      throw error;
+    });
+    modules.set(resolved, module);
+  }
+  return module;
+}
+
+// node_modules/@earendil-works/pi-codemode/dist/runtime/protocol.js
+function isWorkerToHostMessage(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const type = value.type;
+  return type === "call" || type === "output" || type === "done" || type === "crash";
+}
+
+// node_modules/@earendil-works/pi-codemode/dist/runtime/host.js
+var DEFAULT_TIMEOUT_MS = 300000;
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var RESERVED_GLOBALS = new Set([
+  "tools",
+  "ALL_TOOLS",
+  "console",
+  "text",
+  "image",
+  "exit",
+  "globalThis",
+  "store",
+  "load"
+]);
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function serializeStore(store) {
+  const serialized = {};
+  for (const [key, value] of Object.entries(store ?? {})) {
+    const json = JSON.stringify(value);
+    if (json !== undefined)
+      serialized[key] = json;
+  }
+  return serialized;
+}
+function parseStoreWrites(json) {
+  const writes = { set: {}, delete: [] };
+  for (const [key, value] of JSON.parse(json)) {
+    if (value === undefined)
+      writes.delete.push(key);
+    else
+      writes.set[key] = JSON.parse(value);
+  }
+  return writes;
+}
+function defaultWorkerUrl() {
+  return new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url);
+}
+
+class Execution {
+  promise;
+  resolveResult;
+  worker;
+  interrupt = new SharedArrayBuffer(4);
+  tools;
+  globals;
+  signal;
+  timer;
+  output = [];
+  calls = [];
+  pending = new Map;
+  finished = false;
+  constructor(options) {
+    this.promise = new Promise((resolve) => {
+      this.resolveResult = resolve;
+    });
+    this.tools = options.tools;
+    this.globals = options.globals;
+    this.signal = options.signal;
+    if (Number.isFinite(options.timeoutMs)) {
+      this.timer = setTimeout(() => {
+        this.finish({ kind: "timeout", message: `Execution timed out after ${options.timeoutMs} ms` });
+      }, options.timeoutMs);
+    }
+    if (options.signal) {
+      if (options.signal.aborted) {
+        this.onAbort();
+      } else {
+        options.signal.addEventListener("abort", this.onAbort, { once: true });
+      }
+    }
+    options.wasm.then((wasm) => this.start(options, wasm), (error) => {
+      this.finish({ kind: "sandbox", message: `Failed to load QuickJS: ${errorMessage(error)}` });
+    });
+  }
+  abort(message) {
+    this.finish({ kind: "aborted", message });
+    return this.promise;
+  }
+  start(options, wasm) {
+    if (this.finished)
+      return;
+    const workerData = {
+      code: options.code,
+      tools: [...options.tools.values()].map((tool) => ({
+        name: tool.name,
+        jsName: toCodemodeIdentifier(tool.name),
+        description: tool.description ?? ""
+      })),
+      globals: [...options.globals.values()].map((global) => ({
+        name: global.name,
+        spread: global.spread === true
+      })),
+      wasm,
+      memoryLimitBytes: options.memoryLimitBytes,
+      store: options.store,
+      interrupt: this.interrupt
+    };
+    let worker;
+    try {
+      worker = new Worker(options.workerUrl, { workerData });
+    } catch (error) {
+      this.finish({ kind: "sandbox", message: `Failed to start worker: ${errorMessage(error)}` });
+      return;
+    }
+    this.worker = worker;
+    worker.on("message", (message) => this.handleMessage(message));
+    worker.on("error", (error) => {
+      this.finish({
+        kind: "sandbox",
+        name: error instanceof Error ? error.name : undefined,
+        message: errorMessage(error)
+      });
+    });
+    worker.on("exit", (code) => {
+      this.finish({ kind: "sandbox", message: `Worker exited with code ${code} before the script settled` });
+    });
+  }
+  onAbort = () => {
+    const reason = this.signal?.reason;
+    this.finish({ kind: "aborted", message: reason instanceof Error ? reason.message : "Execution aborted" });
+  };
+  post(message) {
+    this.worker?.postMessage(message);
+  }
+  handleMessage(message) {
+    if (this.finished || !isWorkerToHostMessage(message))
+      return;
+    switch (message.type) {
+      case "output":
+        this.output.push(message.item);
+        break;
+      case "call":
+        this.handleCall(message);
+        break;
+      case "done":
+        this.handleDone(message);
+        break;
+      case "crash":
+        this.finish({ kind: "sandbox", message: message.message });
+        break;
+    }
+  }
+  handleDone(message) {
+    if (!message.ok) {
+      const parsed = JSON.parse(message.error);
+      this.finish({ kind: "script", ...parsed });
+      return;
+    }
+    this.finish(undefined, message.value === undefined ? undefined : JSON.parse(message.value), message.writes);
+  }
+  async handleCall(message) {
+    const { id, name } = message;
+    const isTool = message.target === "tool";
+    const record = isTool ? { name, status: "cancelled", durationMs: 0 } : undefined;
+    if (record)
+      this.calls.push(record);
+    const pending = { record, startedAt: performance.now(), controller: new AbortController };
+    this.pending.set(id, pending);
+    let status;
+    let reply;
+    try {
+      const tool = (isTool ? this.tools : this.globals).get(name);
+      if (!tool)
+        throw new Error(`Unknown ${isTool ? "tool" : "global"} "${name}"`);
+      const args = message.args === undefined ? undefined : JSON.parse(message.args);
+      const value = await tool.execute(args, { signal: pending.controller.signal });
+      reply = { type: "result", id, ok: true, payload: value === undefined ? undefined : JSON.stringify(value) };
+      status = "ok";
+    } catch (error) {
+      reply = { type: "result", id, ok: false, payload: errorMessage(error) };
+      status = "error";
+    }
+    if (!this.pending.delete(id))
+      return;
+    if (record) {
+      record.status = status;
+      record.durationMs = performance.now() - pending.startedAt;
+    }
+    this.post(reply);
+  }
+  finish(error, value, writes) {
+    if (this.finished)
+      return;
+    this.finished = true;
+    clearTimeout(this.timer);
+    this.signal?.removeEventListener("abort", this.onAbort);
+    const now = performance.now();
+    for (const pending of this.pending.values()) {
+      if (pending.record)
+        pending.record.durationMs = now - pending.startedAt;
+      pending.controller.abort();
+    }
+    this.pending.clear();
+    const result = error ? { ok: false, error, output: this.output, calls: this.calls } : {
+      ok: true,
+      value,
+      output: this.output,
+      calls: this.calls,
+      storeWrites: writes === undefined ? { set: {}, delete: [] } : parseStoreWrites(writes)
+    };
+    if (!this.worker) {
+      this.resolveResult(result);
+      return;
+    }
+    Atomics.store(new Int32Array(this.interrupt), 0, 1);
+    this.worker.terminate().catch(() => {
+      return;
+    }).then(() => this.resolveResult(result));
+  }
+}
+
+class CodemodeSandbox {
+  toolsByName = new Map;
+  globalsByName = new Map;
+  timeoutMs;
+  memoryLimitBytes;
+  wasm;
+  workerUrl;
+  running = new Set;
+  closed = false;
+  constructor(options = {}) {
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.memoryLimitBytes = options.memoryLimitBytes;
+    this.wasm = options.wasm;
+    this.workerUrl = options.workerUrl ?? defaultWorkerUrl();
+    for (const tool of options.tools ?? [])
+      this.registerTool(tool);
+    const namespaces = new Set;
+    for (const global of options.globals ?? []) {
+      const parts = global.name.split(".");
+      if (parts.length > 2 || !parts.every((part) => IDENTIFIER.test(part)) || RESERVED_GLOBALS.has(parts[0])) {
+        throw new Error(`Invalid global name "${global.name}"`);
+      }
+      if (this.globalsByName.has(global.name))
+        throw new Error(`Global "${global.name}" is already registered`);
+      if (parts.length === 2)
+        namespaces.add(parts[0]);
+      this.globalsByName.set(global.name, global);
+    }
+    for (const name of namespaces) {
+      if (this.globalsByName.has(name))
+        throw new Error(`Global "${name}" conflicts with the namespace "${name}"`);
+    }
+  }
+  registerTool(tool) {
+    if (this.toolsByName.has(tool.name))
+      throw new Error(`Tool "${tool.name}" is already registered`);
+    this.toolsByName.set(tool.name, tool);
+  }
+  unregisterTool(name) {
+    return this.toolsByName.delete(name);
+  }
+  get tools() {
+    return [...this.toolsByName.values()];
+  }
+  get globals() {
+    return [...this.globalsByName.values()];
+  }
+  execute(code, options = {}) {
+    if (this.closed)
+      return Promise.reject(new Error("Sandbox is closed"));
+    const execution = new Execution({
+      code,
+      tools: new Map(this.toolsByName),
+      globals: this.globalsByName,
+      timeoutMs: options.timeoutMs ?? this.timeoutMs,
+      signal: options.signal,
+      memoryLimitBytes: this.memoryLimitBytes,
+      store: serializeStore(options.store),
+      wasm: this.wasm === undefined ? loadQuickJSWasm() : Promise.resolve(this.wasm),
+      workerUrl: this.workerUrl
+    });
+    this.running.add(execution);
+    return execution.promise.finally(() => this.running.delete(execution));
+  }
+  async close() {
+    this.closed = true;
+    await Promise.all([...this.running].map((execution) => execution.abort("Sandbox closed")));
+  }
+}
+// node_modules/@earendil-works/pi-codemode/dist/runtime/prelude-source.js
+var MAX_STORE_VALUE_CHARS = 256 * 1024;
+var MAX_STORE_TOTAL_CHARS = 1024 * 1024;
+var IMAGE_HELPER_EXPECTS = "image expects a non-empty image URL string, an object with image_url, or a raw MCP image block";
+var PRELUDE_SOURCE = `(function (bridge, toolsJson, globalsJson, storeJson) {
+	"use strict";
+	const stringify = JSON.stringify;
+	const parse = JSON.parse;
+	const promiseThen = Promise.prototype.then;
+	const ErrorCtor = Error;
+	const TypeErrorCtor = TypeError;
+	const pending = new Map();
+	let nextId = 1;
+	let finished = false;
+	// Thrown by exit() to unwind the script after it already reported success.
+	const EXIT = Object.freeze({});
+
+	function done(ok, payload, writes) {
+		if (finished) return;
+		finished = true;
+		bridge("done", ok, payload, writes);
+	}
+
+	function serialize(value) {
+		return value === undefined ? undefined : stringify(value);
+	}
+
+	// QuickJS stacks list frames only. Prefix "Name: message" like V8 so the
+	// text reads the same as a Node error, and drop this prelude's frames.
+	function errorText(error) {
+		const head = error.message ? error.name + ": " + error.message : String(error.name);
+		const frames =
+			typeof error.stack === "string"
+				? error.stack.split("\\n").filter((line) => line.trim() && !line.includes("codemode-prelude.js"))
+				: [];
+		return [head, ...frames].join("\\n");
+	}
+
+	function format(value) {
+		if (typeof value === "string") return value;
+		if (value instanceof ErrorCtor) return errorText(value);
+		try {
+			const json = stringify(value);
+			return json === undefined ? String(value) : json;
+		} catch {
+			return String(value);
+		}
+	}
+
+	function describeError(error) {
+		if (error instanceof ErrorCtor) {
+			return stringify({ name: error.name, message: error.message, stack: errorText(error) });
+		}
+		return stringify({ message: format(error) });
+	}
+
+	function caller(kind, name, spread) {
+		return (...args) =>
+			new Promise((resolve, reject) => {
+				let json;
+				try {
+					json = serialize(spread ? args : args[0]);
+				} catch (error) {
+					reject(error);
+					return;
+				}
+				const id = nextId++;
+				pending.set(id, { resolve, reject });
+				bridge(kind, id, name, json);
+			});
+	}
+
+	const tools = Object.create(null);
+	const allTools = [];
+	for (const { name, jsName, description } of parse(toolsJson)) {
+		const fn = caller("call", name);
+		// The first tool wins when two names normalize to the same identifier.
+		if (!(jsName in tools)) {
+			tools[jsName] = fn;
+			allTools.push(Object.freeze({ name: jsName, description }));
+		}
+		if (!(name in tools)) tools[name] = fn;
+	}
+	Object.freeze(tools);
+	Object.freeze(allTools);
+
+	const namespaces = new Map();
+	for (const { name, spread } of parse(globalsJson)) {
+		const fn = caller("global", name, spread);
+		const dot = name.indexOf(".");
+		if (dot === -1) {
+			Object.defineProperty(globalThis, name, { value: fn, enumerable: true });
+			continue;
+		}
+		const namespace = name.slice(0, dot);
+		if (!namespaces.has(namespace)) namespaces.set(namespace, Object.create(null));
+		namespaces.get(namespace)[name.slice(dot + 1)] = fn;
+	}
+	for (const [namespace, members] of namespaces) {
+		Object.defineProperty(globalThis, namespace, { value: Object.freeze(members), enumerable: true });
+	}
+
+	// key -> JSON text. Sizes count key and JSON characters.
+	const stored = new Map(Object.entries(parse(storeJson)));
+	const writes = new Map();
+	let storedChars = 0;
+	for (const [key, json] of stored) storedChars += key.length + json.length;
+
+	function checkKey(name, key) {
+		if (typeof key !== "string") throw new TypeError(name + "() key must be a string");
+	}
+
+	function store(key, value) {
+		checkKey("store", key);
+		const previous = stored.has(key) ? key.length + stored.get(key).length : 0;
+		if (value === undefined) {
+			stored.delete(key);
+			storedChars -= previous;
+			writes.set(key, undefined);
+			return;
+		}
+		let json;
+		try {
+			json = stringify(value);
+		} catch (error) {
+			throw new TypeError("store(" + stringify(key) + ") value is not JSON-serializable: " + format(error));
+		}
+		if (json === undefined) {
+			throw new TypeError("store(" + stringify(key) + ") value is not JSON-serializable");
+		}
+		if (json.length > ${MAX_STORE_VALUE_CHARS}) {
+			throw new RangeError("store(" + stringify(key) + ") value exceeds ${MAX_STORE_VALUE_CHARS} characters of JSON");
+		}
+		const next = storedChars - previous + key.length + json.length;
+		if (next > ${MAX_STORE_TOTAL_CHARS}) {
+			throw new RangeError("store is full: stored values would exceed ${MAX_STORE_TOTAL_CHARS} characters of JSON");
+		}
+		stored.set(key, json);
+		storedChars = next;
+		writes.set(key, json);
+	}
+
+	function load(key) {
+		checkKey("load", key);
+		const json = stored.get(key);
+		return json === undefined ? undefined : parse(json);
+	}
+
+	function serializeWrites() {
+		const entries = [];
+		for (const [key, json] of writes) entries.push(json === undefined ? [key] : [key, json]);
+		return stringify(entries);
+	}
+
+	Object.defineProperty(globalThis, "store", { value: store, enumerable: true });
+	Object.defineProperty(globalThis, "load", { value: load, enumerable: true });
+
+	// Primitives become their string form, everything else JSON.
+	function outputText(value) {
+		if (value === undefined || value === null || typeof value !== "object" && typeof value !== "function") {
+			return String(value);
+		}
+		const json = stringify(value);
+		return json === undefined ? String(value) : json;
+	}
+
+	function text(value) {
+		let rendered;
+		try {
+			rendered = outputText(value);
+		} catch (error) {
+			throw new TypeErrorCtor(error instanceof ErrorCtor ? error.message : String(error));
+		}
+		if (!finished) bridge("output", "text", rendered);
+	}
+
+	function imageUrl(value) {
+		if (typeof value === "string") return value;
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
+		}
+		if (value.image_url !== undefined) {
+			if (typeof value.image_url !== "string") throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
+			return value.image_url;
+		}
+		if (typeof value.type !== "string") throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
+		if (value.type !== "image") {
+			throw new TypeErrorCtor('image only accepts MCP image blocks, got "' + value.type + '"');
+		}
+		if (typeof value.data !== "string" || value.data === "") throw new TypeErrorCtor("image expected MCP image data");
+		if (value.data.toLowerCase().startsWith("data:")) return value.data;
+		const mimeType = typeof value.mimeType === "string" && value.mimeType ? value.mimeType : "application/octet-stream";
+		return "data:" + mimeType + ";base64," + value.data;
+	}
+
+	function image(value) {
+		const url = imageUrl(value);
+		if (url === "") throw new TypeErrorCtor(${JSON.stringify(IMAGE_HELPER_EXPECTS)});
+		const colon = url.indexOf(":");
+		const scheme = colon === -1 ? "" : url.slice(0, colon).toLowerCase();
+		if (scheme === "http" || scheme === "https") {
+			throw new TypeErrorCtor("remote image URLs are not supported in tool outputs. Pass a base64 data URI instead");
+		}
+		const comma = url.indexOf(",");
+		const header = comma === -1 ? [] : url.slice(colon + 1, comma).split(";");
+		if (scheme !== "data" || comma === -1 || header.slice(1).every((part) => part.toLowerCase() !== "base64")) {
+			throw new TypeErrorCtor("invalid image output. Pass a base64 data URI instead");
+		}
+		if (!finished) bridge("output", "image", url.slice(comma + 1), header[0] || "application/octet-stream");
+	}
+
+	function exit() {
+		let writesJson;
+		try {
+			writesJson = serializeWrites();
+		} catch (error) {
+			done(false, describeError(error));
+			throw EXIT;
+		}
+		done(true, undefined, writesJson);
+		throw EXIT;
+	}
+
+	const console = {};
+	for (const level of ["log", "info", "warn", "error", "debug"]) {
+		console[level] = (...args) => {
+			if (!finished) bridge("output", "text", args.map(format).join(" "));
+		};
+	}
+	Object.freeze(console);
+
+	Object.defineProperty(globalThis, "tools", { value: tools, enumerable: true });
+	Object.defineProperty(globalThis, "ALL_TOOLS", { value: allTools, enumerable: true });
+	Object.defineProperty(globalThis, "console", { value: console, enumerable: true });
+	Object.defineProperty(globalThis, "text", { value: text, enumerable: true });
+	Object.defineProperty(globalThis, "image", { value: image, enumerable: true });
+	Object.defineProperty(globalThis, "exit", { value: exit, enumerable: true });
+
+	return {
+		settle(id, ok, payload) {
+			const entry = pending.get(id);
+			if (!entry) return;
+			pending.delete(id);
+			if (!ok) {
+				entry.reject(new ErrorCtor(payload));
+				return;
+			}
+			let value;
+			try {
+				value = payload === undefined ? undefined : parse(payload);
+			} catch (error) {
+				entry.reject(error);
+				return;
+			}
+			entry.resolve(value);
+		},
+		run(fn) {
+			let promise;
+			try {
+				promise = fn(tools, console);
+			} catch (error) {
+				done(false, describeError(error));
+				return;
+			}
+			promiseThen.call(
+				promise,
+				(value) => {
+					let json;
+					try {
+						json = serialize(value);
+					} catch (error) {
+						done(false, describeError(error));
+						return;
+					}
+					done(true, json, serializeWrites());
+				},
+				(error) => {
+					done(false, describeError(error));
+				},
+			);
+		},
+		stalled() {
+			if (finished || pending.size > 0) return false;
+			done(
+				false,
+				stringify({
+					name: "Error",
+					message:
+						"The script is waiting on a promise that can never settle: no tool call is pending, and timers do not exist here.",
+				}),
+			);
+			return true;
+		},
+	};
+})`;
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/codemode/execute.js
+var ARGS_PREVIEW_CHARS = 200;
+var ERROR_PREVIEW_CHARS = 500;
+var MAX_CONCURRENT_MODEL_CALLS = 4;
+var CODEMODE_MEMORY_LIMIT_BYTES = 256 * 1024 * 1024;
+var MODEL_TYPES = new Set(["chat", "image", "classifier"]);
+function truncateText(text, maxChars) {
+  return text.length > maxChars ? `${text.slice(0, maxChars - 3)}...` : text;
+}
+function previewArgs(args) {
+  if (args === undefined)
+    return "";
+  try {
+    return truncateText(JSON.stringify(args) ?? "", ARGS_PREVIEW_CHARS);
+  } catch {
+    return "";
+  }
+}
+function textOf(result) {
+  return (result.content ?? []).filter((block) => block.type === "text").map((block) => block.text).join(`
+`);
+}
+function toModelType(value) {
+  if (typeof value === "string" && MODEL_TYPES.has(value))
+    return value;
+  throw new Error(`Unknown model type ${JSON.stringify(value)}. Use "chat", "image", or "classifier".`);
+}
+function toProvider(value) {
+  if (value === undefined || value === null)
+    return;
+  if (typeof value !== "string")
+    throw new Error("provider must be a string");
+  return value;
+}
+function toModelInfo(model) {
+  const info = { ...model };
+  delete info.headers;
+  return info;
+}
+function createLimiter(limit) {
+  let active = 0;
+  const waiting = [];
+  return async (run) => {
+    if (active >= limit)
+      await new Promise((resolve) => waiting.push(resolve));
+    active++;
+    try {
+      return await run();
+    } finally {
+      active--;
+      waiting.shift()?.();
+    }
+  };
+}
+function isStoreEntryData(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  const { set, delete: deleted } = data;
+  return typeof set === "object" && set !== null && Array.isArray(deleted) && deleted.every((key) => typeof key === "string");
+}
+function readCodemodeStore(branch) {
+  const store = new Map;
+  for (const entry of branch) {
+    if (entry.type !== "custom" || entry.customType !== CODEMODE_STORE_ENTRY_TYPE || !isStoreEntryData(entry.data)) {
+      continue;
+    }
+    for (const key of entry.data.delete)
+      store.delete(key);
+    for (const [key, value] of Object.entries(entry.data.set))
+      store.set(key, value);
+  }
+  return Object.fromEntries(store);
+}
+var DEFAULT_MAX_OUTPUT_TOKENS = 1e4;
+var CHARS_PER_TOKEN = 4;
+function valueText(value) {
+  if (typeof value === "string")
+    return value;
+  return JSON.stringify(value) ?? String(value);
+}
+function formatCallSummary(calls) {
+  if (calls.length === 0)
+    return "No tool calls were made.";
+  return `Tool calls made before the failure (they are not undone): ${calls.map((call) => `${call.name} (${call.status})`).join(", ")}`;
+}
+function formatError(result, calls) {
+  const { error } = result;
+  const head = error.kind === "script" ? error.stack ?? `${error.name ?? "Error"}: ${error.message}` : error.kind === "timeout" ? `Script timed out: ${error.message}` : error.kind === "aborted" ? `Script aborted: ${error.message}` : `Script sandbox failed: ${error.message}`;
+  return `${head}
+
+${formatCallSummary(calls)}`;
+}
+async function spillOutput(text) {
+  const path = join(tmpdir(), `pi-codemode-${randomBytes(8).toString("hex")}.txt`);
+  try {
+    await writeFile(path, text);
+    return { path };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function truncateOutput(items, maxTokens) {
+  const texts = items.filter((item) => item.type === "text").map((item) => item.text);
+  const combined = texts.join(`
+`);
+  const budget = maxTokens * CHARS_PER_TOKEN;
+  if (texts.length === 0 || combined.length <= budget)
+    return { items };
+  const headChars = Math.floor(budget / 2);
+  const tailChars = budget - headChars;
+  const removed = combined.length - headChars - tailChars;
+  const head = combined.slice(0, headChars);
+  const tail = tailChars > 0 ? combined.slice(-tailChars) : "";
+  let text = `Warning: truncated output (original token count: ${Math.ceil(combined.length / CHARS_PER_TOKEN)})
+Total output lines: ${combined.split(`
+`).length}
+
+${head}…${Math.ceil(removed / CHARS_PER_TOKEN)} tokens truncated…${tail}`;
+  const spilled = await spillOutput(combined);
+  text += "path" in spilled ? `
+
+[Full output: ${spilled.path} (read with offset/limit)]` : `
+
+[Could not save the full output: ${spilled.error}]`;
+  return {
+    items: [{ type: "text", text }, ...items.filter((item) => item.type === "image")],
+    ..."path" in spilled ? { fullOutputPath: spilled.path } : {}
+  };
+}
+function toScriptValue(tool, outcome) {
+  const { result } = outcome;
+  if (tool.outputSchema && result.structuredContent !== undefined)
+    return result.structuredContent;
+  const text = textOf(result);
+  if (outcome.isError)
+    throw new Error(text || `Tool "${tool.name}" failed`);
+  return text;
+}
+async function executeCodemode(toolCallId, input, signal, onUpdate, ctx, options = {}) {
+  const startedAt = performance.now();
+  const { code, options: sourceOptions } = parseCodemodeSource(input.code);
+  const calls = [];
+  let modelUsage;
+  const addModelUsage = (usage) => {
+    modelUsage = modelUsage ? combineUsage(modelUsage, usage) : usage;
+  };
+  const snapshot = () => ({ calls: calls.map((call) => ({ ...call })) });
+  const publish = () => onUpdate?.({ content: [], details: snapshot() });
+  const callable = ctx ? getCodemodeCallableTools(ctx.tools) : [];
+  const samples = new Map(callable.map((tool) => [tool.name, renderToolSample(toCodemodeDeclaration(tool))]));
+  const sandboxTools = callable.map((tool) => ({
+    name: tool.name,
+    description: samples.get(tool.name),
+    execute: async (args, { signal: callSignal }) => {
+      const record = {
+        id: `${toolCallId}/?`,
+        name: tool.name,
+        args: previewArgs(args),
+        status: "running"
+      };
+      calls.push(record);
+      publish();
+      const callStartedAt = performance.now();
+      if (!ctx)
+        throw new Error("Tool calls need a session");
+      const outcome = await ctx.executeTool(tool.name, args, { signal: callSignal });
+      record.id = outcome.toolCall.id;
+      record.durationMs = performance.now() - callStartedAt;
+      if (outcome.isError) {
+        record.status = callSignal.aborted ? "cancelled" : "error";
+        record.error = truncateText(textOf(outcome.result) || `Tool "${tool.name}" failed`, ERROR_PREVIEW_CHARS);
+      } else {
+        record.status = "ok";
+      }
+      publish();
+      return toScriptValue(tool, outcome);
+    }
+  }));
+  const sandbox = new CodemodeSandbox({
+    tools: sandboxTools,
+    globals: [
+      ...createDiscoveryGlobals(callable, samples, options),
+      ...options.models && ctx ? createModelGlobals(ctx.modelRegistry, toolCallId, calls, publish, addModelUsage) : []
+    ],
+    timeoutMs: sourceOptions.timeoutMs ?? Number.POSITIVE_INFINITY,
+    memoryLimitBytes: CODEMODE_MEMORY_LIMIT_BYTES,
+    wasm: loadQuickJSWasm(getQuickJSWasmPath()),
+    workerUrl: getCodemodeWorkerUrl()
+  });
+  let result;
+  try {
+    const store = ctx ? readCodemodeStore(ctx.sessionManager.getBranch()) : {};
+    result = await sandbox.execute(code, { signal, store });
+  } finally {
+    await sandbox.close();
+  }
+  for (const call of calls) {
+    if (call.status === "running")
+      call.status = "cancelled";
+  }
+  const items = result.output.map((item) => item.type === "text" ? { type: "text", text: item.text } : item);
+  if (result.ok) {
+    const { set, delete: deleted } = result.storeWrites;
+    if (Object.keys(set).length > 0 || deleted.length > 0) {
+      options.appendEntry?.(CODEMODE_STORE_ENTRY_TYPE, { set, delete: deleted });
+    }
+    if (result.value !== undefined)
+      items.push({ type: "text", text: valueText(result.value) });
+  } else {
+    items.push({ type: "text", text: `Script error:
+${formatError(result, calls)}` });
+  }
+  const truncated = await truncateOutput(items, sourceOptions.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS);
+  const wallTime = ((performance.now() - startedAt) / 1000).toFixed(1);
+  const header = `${result.ok ? "Script completed" : "Script failed"}
+Wall time ${wallTime} seconds
+Output:
+`;
+  const details = snapshot();
+  if (truncated.fullOutputPath)
+    details.fullOutputPath = truncated.fullOutputPath;
+  return {
+    content: [{ type: "text", text: header }, ...truncated.items],
+    details,
+    ...modelUsage ? { usage: modelUsage } : {},
+    ...result.ok ? {} : { isError: true }
+  };
+}
+function createDiscoveryGlobals(tools, samples, options) {
+  const ranker = new Bm25Ranker;
+  const entry = (name) => ({ name: toCodemodeIdentifier(name), description: samples.get(name) ?? "" });
+  return [
+    {
+      name: "searchTools",
+      spread: true,
+      execute: (args) => {
+        const [query, searchOptions] = args;
+        if (typeof query !== "string")
+          throw new Error("searchTools() expects a query string");
+        const limit = searchOptions?.limit ?? DEFAULT_TOOL_SEARCH_LIMIT;
+        if (typeof limit !== "number" || !Number.isInteger(limit) || limit <= 0) {
+          throw new Error("searchTools() limit must be a positive integer");
+        }
+        const namespace = searchOptions?.namespace;
+        if (namespace !== undefined && namespace !== null && typeof namespace !== "string") {
+          throw new Error("searchTools() namespace must be a string");
+        }
+        const documents = tools.flatMap((tool) => {
+          const toolNamespace = options.getToolNamespace?.(tool.name);
+          if (namespace && toolNamespace?.name !== namespace)
+            return [];
+          return [createToolSearchDocument(tool, toolNamespace)];
+        });
+        return ranker.rank(query, documents, limit).map((match) => entry(match.name));
+      }
+    },
+    {
+      name: "describeTool",
+      spread: true,
+      execute: (args) => {
+        const [name] = args;
+        if (typeof name !== "string")
+          throw new Error("describeTool() expects a tool name");
+        const tool = tools.find((candidate) => candidate.name === name || toCodemodeIdentifier(candidate.name) === name);
+        return tool ? samples.get(tool.name) : undefined;
+      }
+    }
+  ];
+}
+function createModelGlobals(models, toolCallId, calls, publish, addUsage) {
+  const limit = createLimiter(MAX_CONCURRENT_MODEL_CALLS);
+  let classifyCount = 0;
+  const implementations = {
+    "models.getModelsOfType": (args) => {
+      const [type, provider] = args;
+      return models.getModelsOfType(toModelType(type), toProvider(provider)).map(toModelInfo);
+    },
+    "models.getAvailableOfType": async (args, { signal }) => {
+      const [type, provider] = args;
+      const available = await models.getAvailableOfType(toModelType(type), toProvider(provider), { signal });
+      return available.map(toModelInfo);
+    },
+    "models.getModelOfType": (args) => {
+      const [type, provider, id] = args;
+      if (typeof provider !== "string" || typeof id !== "string") {
+        throw new Error("models.getModelOfType() expects a type, a provider, and an id");
+      }
+      const model = models.getModelOfType(toModelType(type), provider, id);
+      return model === undefined ? undefined : toModelInfo(model);
+    },
+    "models.classify": async (args, { signal }) => {
+      const [model, context] = args;
+      const ref = model;
+      if (typeof ref !== "object" || ref === null || typeof ref.provider !== "string" || typeof ref.id !== "string") {
+        throw new Error("models.classify() expects a model from models.getModelOfType() or models.getAvailableOfType()");
+      }
+      const resolved = models.getModelOfType("classifier", ref.provider, ref.id);
+      if (!resolved)
+        throw new Error(`Unknown classifier model "${ref.provider}/${ref.id}"`);
+      const record = {
+        id: `${toolCallId}/models.classify/${++classifyCount}`,
+        name: "models.classify",
+        args: `${resolved.provider}/${resolved.id}`,
+        status: "running"
+      };
+      calls.push(record);
+      publish();
+      const startedAt = performance.now();
+      const result = await limit(() => models.classify(resolved, context, { signal }));
+      record.durationMs = performance.now() - startedAt;
+      record.status = result.stopReason === "stop" ? "ok" : result.stopReason === "aborted" ? "cancelled" : "error";
+      if (result.errorMessage)
+        record.error = truncateText(result.errorMessage, ERROR_PREVIEW_CHARS);
+      if (result.usage) {
+        record.cost = result.usage.cost.total;
+        addUsage(result.usage);
+      }
+      publish();
+      return result;
+    }
+  };
+  return MODEL_GLOBAL_DECLARATIONS.map((declaration) => ({
+    name: declaration.name,
+    spread: true,
+    execute: implementations[declaration.name]
+  }));
+}
+export {
+  executeCodemode,
+  readCodemodeStore
+};