@desplega.ai/agent-swarm 1.171.0 → 1.172.0

package/dist/execute-h4jgevyw.js

@@ -1,1387 +0,0 @@
-import {
-  Bm25Ranker,
-  CODEMODE_DOCS_PATH,
-  CODEMODE_STORE_ENTRY_TYPE,
-  DEFAULT_TOOL_SEARCH_LIMIT,
-  combineUsage,
-  createToolSearchDocument,
-  getCodemodeCallableTools,
-  parseCodemodeSource,
-  renderToolSample,
-  toCodemodeDeclaration,
-  toCodemodeIdentifier
-} from "./cli-s9y81s7j.js";
-import {
-  formatSize,
-  writeOutputFile
-} from "./cli-rhy7z1rp.js";
-import {
-  getCodemodeWorkerSpecifier,
-  getQuickJSWasmPath
-} from "./cli-5t5my0h8.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-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;
-}
-
-class BridgeError extends Error {
-}
-function parseBridgeJson(json, what) {
-  try {
-    return JSON.parse(json);
-  } catch {
-    throw new BridgeError(`${what} is not valid JSON`);
-  }
-}
-function parseStoreWrites(json) {
-  const entries = parseBridgeJson(json, "store writes");
-  if (!Array.isArray(entries))
-    throw new BridgeError("store writes are not an array");
-  const writes = { set: {}, delete: [] };
-  for (const entry of entries) {
-    if (!Array.isArray(entry) || typeof entry[0] !== "string" || (entry.length === 2 ? typeof entry[1] !== "string" : entry.length !== 1)) {
-      throw new BridgeError("store writes contain a malformed entry");
-    }
-    const [key, value] = entry;
-    if (value === undefined)
-      writes.delete.push(key);
-    else
-      writes.set[key] = parseBridgeJson(value, `store value for ${JSON.stringify(key)}`);
-  }
-  return writes;
-}
-function parseScriptError(json) {
-  const parsed = parseBridgeJson(json, "script error");
-  if (typeof parsed !== "object" || parsed === null)
-    throw new BridgeError("script error is not an object");
-  const { name, message, stack } = parsed;
-  if (typeof message !== "string" || name !== undefined && typeof name !== "string" || stack !== undefined && typeof stack !== "string") {
-    throw new BridgeError("script error is malformed");
-  }
-  return { kind: "script", name, message, stack };
-}
-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) => {
-      try {
-        this.handleMessage(message);
-      } catch (error) {
-        this.finish({
-          kind: "sandbox",
-          message: error instanceof BridgeError ? `Sandbox bridge broken: ${error.message}. The script may have modified built-ins such as a prototype's toJSON.` : `Sandbox host failed: ${errorMessage(error)}`
-        });
-      }
-    });
-    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)
-      return;
-    if (!isWorkerToHostMessage(message))
-      throw new BridgeError("unknown message from the worker");
-    switch (message.type) {
-      case "output":
-        this.output.push(message.item);
-        break;
-      case "call":
-        if (this.pending.has(message.id))
-          throw new BridgeError(`duplicate call id ${message.id}`);
-        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) {
-      this.finish(parseScriptError(message.error));
-      return;
-    }
-    const value = message.value === undefined ? undefined : parseBridgeJson(message.value, "return value");
-    this.finish(undefined, value, parseStoreWrites(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 ?? { set: {}, delete: [] }
-    };
-    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 MAX_OUTPUT_CHARS = 16 * 1024 * 1024;
-var MAX_OUTPUT_ITEMS = 1e5;
-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";
-
-	// Freeze every object reachable from the built-in globals, plus the intrinsics that are only
-	// reachable from instances (iterator and generator prototypes, %TypedArray%).
-	//
-	// Freezing alone breaks ordinary code through the "override mistake": a data property that is
-	// read-only on a prototype cannot be assigned on an instance either, so
-	// this.name = "MyError" in an Error subclass would throw. Commonly overridden properties
-	// become accessors whose setter defines an own property on the instance instead.
-	(function lockdown() {
-		const OVERRIDABLE = new Set(["constructor", "name", "message", "toString", "toLocaleString", "valueOf", "toJSON"]);
-		const seen = new Set([globalThis]);
-		const queue = [];
-		const add = (value) => {
-			if ((typeof value === "object" && value !== null) || typeof value === "function") {
-				if (!seen.has(value)) {
-					seen.add(value);
-					queue.push(value);
-				}
-			}
-		};
-
-		// Accessors from an object literal have no own prototype object, unlike function expressions,
-		// whose prototype.constructor would be converted again without end.
-		function allowOverride(object, key, value, enumerable) {
-			const { get, set } = Object.getOwnPropertyDescriptor(
-				{
-					get accessor() {
-						return value;
-					},
-					set accessor(next) {
-						if (this === object) {
-							throw new TypeError("Cannot assign to read only property '" + String(key) + "' of a built-in");
-						}
-						if ((typeof this !== "object" || this === null) && typeof this !== "function") return;
-						Object.defineProperty(this, key, { value: next, writable: true, enumerable: true, configurable: true });
-					},
-				},
-				"accessor",
-			);
-			Object.defineProperty(object, key, { get, set, enumerable, configurable: false });
-			add(get);
-			add(set);
-		}
-
-		for (const key of Reflect.ownKeys(globalThis)) {
-			const descriptor = Object.getOwnPropertyDescriptor(globalThis, key);
-			add(descriptor.value);
-			add(descriptor.get);
-			add(descriptor.set);
-			if ("value" in descriptor && descriptor.configurable) {
-				Object.defineProperty(globalThis, key, { writable: false, configurable: false });
-			}
-		}
-		add(Object.getPrototypeOf(function* () {}));
-		add(Object.getPrototypeOf(async function () {}));
-		add(Object.getPrototypeOf(async function* () {}));
-		add(Object.getPrototypeOf(Int8Array));
-		add(Object.getPrototypeOf([][Symbol.iterator]()));
-		add(Object.getPrototypeOf(new Map()[Symbol.iterator]()));
-		add(Object.getPrototypeOf(new Set()[Symbol.iterator]()));
-		add(Object.getPrototypeOf(""[Symbol.iterator]()));
-		add(Object.getPrototypeOf(/a/[Symbol.matchAll]("")));
-		if (typeof Iterator === "function") {
-			if (typeof Iterator.prototype.map === "function") add(Object.getPrototypeOf([].values().map((x) => x)));
-			if (typeof Iterator.from === "function") add(Object.getPrototypeOf(Iterator.from({ next() {} })));
-		}
-
-		while (queue.length > 0) {
-			const object = queue.pop();
-			add(Object.getPrototypeOf(object));
-			const descriptors = Object.getOwnPropertyDescriptors(object);
-			for (const key of Reflect.ownKeys(descriptors)) {
-				const descriptor = descriptors[key];
-				if ("value" in descriptor) {
-					add(descriptor.value);
-					if (
-						descriptor.writable &&
-						descriptor.configurable &&
-						(object === Object.prototype || OVERRIDABLE.has(key))
-					) {
-						allowOverride(object, key, descriptor.value, descriptor.enumerable);
-					}
-				} else {
-					add(descriptor.get);
-					add(descriptor.set);
-				}
-			}
-			Object.freeze(object);
-		}
-	})();
-	const stringify = JSON.stringify;
-	const parse = JSON.parse;
-	const promiseThen = Promise.prototype.then;
-	const ErrorCtor = Error;
-	const TypeErrorCtor = TypeError;
-	const RangeErrorCtor = RangeError;
-	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);
-		}
-	}
-
-	// The host requires string fields. A script can set an error's name or message to anything, so
-	// they are coerced, and a value whose coercion throws gets a placeholder.
-	function describeError(error) {
-		try {
-			if (error instanceof ErrorCtor) {
-				return stringify({ name: String(error.name), message: String(error.message), stack: errorText(error) });
-			}
-			return stringify({ message: String(format(error)) });
-		} catch {
-			return stringify({ message: "The script threw a value that cannot be described" });
-		}
-	}
-
-	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);
-
-	// Reading a member that does not exist throws an error that names the close matches, instead of
-	// a later "not a function". \`in\` checks still work.
-	const comparable = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
-	function guard(target, label, names, hint) {
-		return new Proxy(target, {
-			get(object, property, receiver) {
-				if (typeof property !== "string" || property in object || property in Object.prototype || property === "then" || property === "toJSON") {
-					return Reflect.get(object, property, receiver);
-				}
-				const wanted = comparable(property);
-				const exact = names.filter((name) => comparable(name) === wanted);
-				const close = exact.length > 0 ? exact : names.filter((name) => wanted && (comparable(name).includes(wanted) || wanted.includes(comparable(name))));
-				let message = label + "." + property + " does not exist.";
-				if (close.length > 0) message += " Did you mean " + close.slice(0, 5).map((name) => label + "." + name).join(", ") + "?";
-				else if (names.length <= 20) message += " Available: " + names.join(", ") + ".";
-				if (hint) message += " " + hint;
-				message += ' Check for a member with "' + property + '" in ' + label + ".";
-				throw new TypeErrorCtor(message);
-			},
-		});
-	}
-	const toolsProxy = guard(
-		tools,
-		"tools",
-		allTools.map((tool) => tool.name),
-		"ALL_TOOLS lists every tool; searchTools(query) finds tools by topic.",
-	);
-
-	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.freeze(members);
-		const value = guard(members, namespace, Object.keys(members));
-		Object.defineProperty(globalThis, namespace, { value, 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;
-
-	const STORE_HINT =
-		"store() is for small state such as IDs or summaries. Show images with image(), keep large data in variables, or write it to a file with a tool.";
-
-	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 has " + json.length + " characters of JSON, more than the limit of ${MAX_STORE_VALUE_CHARS}. " +
-					STORE_HINT,
-			);
-		}
-		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. Delete keys with store(key, undefined). " +
-					STORE_HINT,
-			);
-		}
-		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 });
-
-	let outputChars = 0;
-	let outputItems = 0;
-
-	// Past the output limits the script fails: done() reports the error, so catching it does not
-	// resume output, and the host ends the script.
-	function output(kind, data, mimeType) {
-		if (finished) return;
-		outputChars += data.length;
-		outputItems++;
-		if (outputChars > ${MAX_OUTPUT_CHARS} || outputItems > ${MAX_OUTPUT_ITEMS}) {
-			const error = new RangeErrorCtor(
-				"script output exceeded the limit of ${MAX_OUTPUT_CHARS} characters or ${MAX_OUTPUT_ITEMS} text(), image(), and console calls. " +
-					"Print a summary instead, or write large data to a file with a tool.",
-			);
-			done(false, describeError(error));
-			throw error;
-		}
-		bridge("output", kind, data, mimeType);
-	}
-
-	// 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));
-		}
-		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;
-		return "data:;base64," + value.data;
-	}
-
-	// Base64 of the signatures of the formats providers accept inline (PNG, JPEG except
-	// JPEG-LS, GIF, "RIFF....WEBP"). Signatures start at byte 0, so their encodings are prefixes.
-	const IMAGE_SIGNATURES = [
-		["image/png", /^iVBORw0KGg/],
-		["image/jpeg", /^[/]9j[/](?!9)/],
-		["image/gif", /^R0lGOD[dl]h/],
-		["image/webp", /^UklG.{8}RUJQ/],
-	];
-
-	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");
-		}
-		// Providers reject the whole request on a bad image, and a persisted image block would be
-		// resent on every later turn. Line breaks from wrapped base64 are dropped. The declared type
-		// is ignored in favor of the detected one, as providers also reject mismatches.
-		const data = url.slice(comma + 1).replace(/\\s+/g, "");
-		if (data.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(data)) {
-			throw new TypeErrorCtor("invalid image output. The image data is not valid base64 (truncated or corrupted?)");
-		}
-		const head = data.slice(0, 16);
-		const signature = IMAGE_SIGNATURES.find(([, pattern]) => pattern.test(head));
-		if (!signature) {
-			throw new TypeErrorCtor("invalid image output. The image data is not a PNG, JPEG, GIF, or WebP image");
-		}
-		output("image", data, signature[0]);
-	}
-
-	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) => {
-			output("console", args.map(format).join(" "));
-		};
-	}
-	Object.freeze(console);
-
-	Object.defineProperty(globalThis, "tools", { value: toolsProxy, 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(toolsProxy, 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 withArticle(word) {
-  return `${/^[aeiou]/.test(word) ? "an" : "a"} ${word}`;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function describeValue(value) {
-  if (value === undefined || value === null)
-    return String(value);
-  if (Array.isArray(value))
-    return value.length === 0 ? "an empty array" : "an array";
-  if (typeof value === "object") {
-    const keys = Object.keys(value);
-    if (keys.length === 0)
-      return "{}";
-    return `{ ${keys.slice(0, 6).join(", ")}${keys.length > 6 ? ", ..." : ""} }`;
-  }
-  return typeof value === "string" ? "a string" : `a ${typeof value}`;
-}
-var CLASSIFIER_CONTEXT_SHAPE = '{ state: { ... }, images?: [{ type: "image", data: <base64>, mimeType }], questions: { <id>: { type: "choice", instructions, criteria: { <label>: <meaning> } } | { type: "score", instructions, criteria: [<lowest level>, ..., <highest level>] } | { type: "bool", instructions, criteria: { true: <meaning>, false: <meaning> } } } }';
-function checkClassifierContext(context) {
-  const fail = (problem) => new Error(`models.classify() ${problem}. Expected context: ${CLASSIFIER_CONTEXT_SHAPE}. See "Classify" in ${CODEMODE_DOCS_PATH}.`);
-  if (!isRecord(context))
-    throw fail(`expects a context object as its second argument, got ${describeValue(context)}`);
-  if (!isRecord(context.state))
-    throw fail(`context.state must be an object, got ${describeValue(context.state)}`);
-  const { images } = context;
-  if (images !== undefined) {
-    if (!Array.isArray(images))
-      throw fail(`context.images must be an array, got ${describeValue(images)}`);
-    images.forEach((image, index) => {
-      if (!isRecord(image) || image.type !== "image" || typeof image.data !== "string" || typeof image.mimeType !== "string") {
-        throw fail(`context.images[${index}] must be an image block, got ${describeValue(image)}`);
-      }
-    });
-  }
-  const { questions } = context;
-  if (!isRecord(questions) || Object.keys(questions).length === 0) {
-    throw fail(`context.questions must map question IDs to questions, got ${describeValue(questions)}`);
-  }
-  const isStrings = (values) => values.length > 0 && values.every((value) => typeof value === "string");
-  for (const [id, question] of Object.entries(questions)) {
-    const at = `context.questions.${id}`;
-    if (!isRecord(question))
-      throw fail(`${at} must be a question object, got ${describeValue(question)}`);
-    if (typeof question.instructions !== "string")
-      throw fail(`${at}.instructions must be a string`);
-    const { criteria } = question;
-    if (question.type === "choice") {
-      if (!isRecord(criteria) || !isStrings(Object.values(criteria))) {
-        throw fail(`${at} is a "choice" question, so criteria must map each label to its meaning`);
-      }
-    } else if (question.type === "score") {
-      if (!Array.isArray(criteria) || !isStrings(criteria)) {
-        throw fail(`${at} is a "score" question, so criteria must list the levels as strings, lowest first`);
-      }
-    } else if (question.type === "bool") {
-      if (!isRecord(criteria) || typeof criteria.true !== "string" || typeof criteria.false !== "string") {
-        throw fail(`${at} is a "bool" question, so criteria must be { true: string, false: string }`);
-      }
-    } else {
-      throw fail(`${at}.type must be "choice", "score", or "bool", got ${JSON.stringify(question.type)}`);
-    }
-  }
-  return context;
-}
-function checkImagesContext(context) {
-  const fail = (problem) => new Error(`models.generateImages() ${problem}. Expected context: { input: [{ type: "text", text: <prompt> }, ...optional { type: "image", data: <base64>, mimeType } references] }. See "Generate images" in ${CODEMODE_DOCS_PATH}.`);
-  if (!isRecord(context))
-    throw fail(`expects a context object as its second argument, got ${describeValue(context)}`);
-  const { input } = context;
-  if (!Array.isArray(input) || input.length === 0) {
-    throw fail(`context.input must be a non-empty array of blocks, got ${describeValue(input)}`);
-  }
-  input.forEach((block, index) => {
-    if (isRecord(block) && block.type === "text" && typeof block.text === "string")
-      return;
-    if (isRecord(block) && block.type === "image" && typeof block.data === "string" && typeof block.mimeType === "string") {
-      return;
-    }
-    throw fail(`context.input[${index}] must be a text or image block, got ${describeValue(block)}`);
-  });
-  return context;
-}
-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 formatOutput(output) {
-  const total = output.filter((item) => item.type === "text" && !item.console).length;
-  const items = [];
-  const consoleLines = [];
-  let index = 0;
-  for (const item of output) {
-    if (item.type === "image") {
-      items.push(item);
-    } else if (item.console) {
-      consoleLines.push(item.text);
-    } else {
-      index++;
-      items.push({ type: "text", text: total > 1 ? `==> text ${index}/${total} <==
-${item.text}` : item.text });
-    }
-  }
-  if (consoleLines.length > 0) {
-    items.push({ type: "text", text: `<console_output>
-${consoleLines.join(`
-`)}
-</console_output>` });
-  }
-  return items;
-}
-function joinAdjacentText(items) {
-  const joined = [];
-  for (const item of items) {
-    const last = joined.at(-1);
-    if (item.type === "text" && last?.type === "text") {
-      const separator = last.text === "" || last.text.endsWith(`
-`) ? "" : `
-`;
-      joined[joined.length - 1] = { type: "text", text: `${last.text}${separator}${item.text}` };
-    } else {
-      joined.push(item);
-    }
-  }
-  return joined;
-}
-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) {
-  try {
-    return { path: await writeOutputFile("pi-codemode", ".txt", text) };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : String(error) };
-  }
-}
-var IMAGE_EXTENSIONS = {
-  "image/png": ".png",
-  "image/jpeg": ".jpg",
-  "image/gif": ".gif",
-  "image/webp": ".webp"
-};
-async function saveImages(items) {
-  const labels = new Map;
-  const label = async ({ data, mimeType }) => {
-    const bytes = Buffer.from(data, "base64");
-    const kind = `${mimeType}, ${formatSize(bytes.length)}`;
-    const extension = IMAGE_EXTENSIONS[mimeType];
-    if (!extension)
-      throw new Error(`No file extension for image type ${mimeType}`);
-    try {
-      const path = await writeOutputFile("pi-codemode", extension, bytes);
-      return `[Image saved to ${path} (${kind})]`;
-    } catch (error) {
-      return `[Image (${kind}) could not be saved: ${error instanceof Error ? error.message : String(error)}]`;
-    }
-  };
-  const result = await Promise.all(items.map(async (item) => {
-    if (item.type !== "image")
-      return [item];
-    let pending = labels.get(item.data);
-    if (!pending) {
-      pending = label(item);
-      labels.set(item.data, pending);
-    }
-    return [{ type: "text", text: await pending }, item];
-  }));
-  return result.flat();
-}
-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;
-  let generatedImages = 0;
-  const addGeneratedImages = (count) => {
-    generatedImages += count;
-  };
-  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 guidelines = options.getToolGuidelines?.();
-  const samples = new Map(callable.map((tool) => [tool.name, renderToolSample(toCodemodeDeclaration(tool, guidelines?.get(tool.name)))]));
-  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, addGeneratedImages) : []
-    ],
-    timeoutMs: sourceOptions.timeoutMs ?? Number.POSITIVE_INFINITY,
-    memoryLimitBytes: CODEMODE_MEMORY_LIMIT_BYTES,
-    wasm: loadQuickJSWasm(getQuickJSWasmPath()),
-    workerUrl: getCodemodeWorkerSpecifier()
-  });
-  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 scriptOutput = [...result.output];
-  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)
-      scriptOutput.push({ type: "text", text: valueText(result.value) });
-  }
-  const items = formatOutput(scriptOutput);
-  if (!result.ok)
-    items.push({ type: "text", text: `Script error:
-${formatError(result, calls)}` });
-  if (generatedImages > 0 && !items.some((item) => item.type === "image")) {
-    items.push({
-      type: "text",
-      text: `Note: models.generateImages() returned ${generatedImages} image${generatedImages === 1 ? "" : "s"} that the script did not show. Show each image block of result.output with image(block).`
-    });
-  }
-  const truncated = await truncateOutput(joinAdjacentText(items), sourceOptions.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS);
-  const output = joinAdjacentText(await saveImages(truncated.items));
-  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 }, ...output],
-    details,
-    ...modelUsage ? { usage: modelUsage } : {},
-    ...result.ok ? {} : { isError: true }
-  };
-}
-function isNamespaceName(namespace, query) {
-  const id = toCodemodeIdentifier(namespace);
-  const queryId = toCodemodeIdentifier(query);
-  const suffix = (name) => name.includes("__") ? name.slice(name.lastIndexOf("__") + 2) : undefined;
-  return namespace === query || id === queryId || suffix(namespace) === query || suffix(id) === queryId;
-}
-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 || !isNamespaceName(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;
-      }
-    },
-    {
-      name: "describeNamespace",
-      spread: true,
-      execute: (args) => {
-        const [name] = args;
-        if (typeof name !== "string")
-          throw new Error("describeNamespace() expects a namespace name");
-        let namespace;
-        const names = [];
-        for (const tool of tools) {
-          const toolNamespace = options.getToolNamespace?.(tool.name);
-          if (!toolNamespace || !isNamespaceName(toolNamespace.name, name))
-            continue;
-          namespace ??= toolNamespace;
-          names.push(toCodemodeIdentifier(tool.name));
-        }
-        if (!namespace)
-          return;
-        return {
-          name: namespace.name,
-          ...namespace.description ? { description: namespace.description } : {},
-          ...namespace.instructions ? { instructions: namespace.instructions } : {},
-          tools: names
-        };
-      }
-    }
-  ];
-}
-function createModelGlobals(models, toolCallId, calls, publish, addUsage, addGeneratedImages) {
-  const limit = createLimiter(MAX_CONCURRENT_MODEL_CALLS);
-  let callCount = 0;
-  const runModelCall = async (name, type, [model, context], checkContext, run) => {
-    const listHint = `List the ${type} models you can use with models.getAvailableOfType("${type}").`;
-    if (!isRecord(model) || typeof model.provider !== "string" || typeof model.id !== "string") {
-      const undefinedHint = model === undefined || model === null ? " models.getModelOfType() returns undefined for an unknown provider or id." : "";
-      throw new Error(`${name}() expects ${withArticle(type)} model as its first argument, got ${describeValue(model)}.${undefinedHint} ${listHint}`);
-    }
-    const { provider, id } = model;
-    const ref = `${provider}/${id}`;
-    const resolved = models.getModelOfType(type, provider, id);
-    if (!resolved) {
-      const actualType = [...MODEL_TYPES].find((other) => other !== type && models.getModelOfType(other, provider, id) !== undefined);
-      throw new Error(actualType ? `"${ref}" is ${withArticle(actualType)} model, not ${withArticle(type)} model. ${listHint}` : `Unknown ${type} model "${ref}". ${listHint}`);
-    }
-    const checked = checkContext(context);
-    const record = {
-      id: `${toolCallId}/${name}/${++callCount}`,
-      name,
-      args: `${resolved.provider}/${resolved.id}`,
-      status: "running"
-    };
-    calls.push(record);
-    publish();
-    const startedAt = performance.now();
-    const result = await limit(() => run(resolved, checked));
-    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;
-  };
-  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(type, provider, id) expects three strings, got (${args.map(describeValue).join(", ")}). The provider and the id are separate arguments, for example models.getModelOfType("classifier", "typesafe", "jev-latest").`);
-      }
-      const model = models.getModelOfType(toModelType(type), provider, id);
-      return model === undefined ? undefined : toModelInfo(model);
-    },
-    "models.classify": (args, { signal }) => runModelCall("models.classify", "classifier", args, checkClassifierContext, (resolved, context) => models.classify(resolved, context, { signal })),
-    "models.generateImages": (args, { signal }) => runModelCall("models.generateImages", "image", args, checkImagesContext, async (resolved, context) => {
-      const result = await models.generateImages(resolved, context, { signal });
-      addGeneratedImages(result.output.filter((block) => block.type === "image").length);
-      return result;
-    })
-  };
-  return Object.entries(implementations).map(([name, execute]) => ({ name, spread: true, execute }));
-}
-export {
-  executeCodemode,
-  readCodemodeStore
-};