@wahack/pi-coding-agent 15.11.0

package/src/eval/js/shared/runtime.ts

@@ -0,0 +1,352 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Console } from "node:console";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { Writable } from "node:stream";
+import * as util from "node:util";
+
+import { logger } from "@oh-my-pi/pi-utils";
+
+import { createHelpers, type HelperBundle } from "./helpers";
+import { awaitMaybePromise, indirectEval } from "./indirect-eval";
+import { LocalModuleLoader } from "./local-module-loader";
+import { JAVASCRIPT_PRELUDE_SOURCE } from "./prelude";
+import { wrapCode } from "./rewrite-imports";
+import type { JsDisplayOutput, JsStatusEvent } from "./types";
+
+/**
+ * Per-run callbacks. Runtime globals resolve these from AsyncLocalStorage so
+ * overlapping async cells can route output/tool calls back to their own run.
+ */
+export interface RuntimeHooks {
+	onText(chunk: string): void;
+	onDisplay(output: JsDisplayOutput): void;
+	callTool(name: string, args: unknown): Promise<unknown>;
+}
+
+export interface RunContext {
+	runId: string;
+	hooks: RuntimeHooks;
+	cwd: string;
+	finalExpressionSet: boolean;
+	finalExpressionValue: unknown;
+}
+
+export interface RuntimeOptions {
+	initialCwd: string;
+	sessionId: string;
+	/**
+	 * Extra globals installed alongside `__omp_helpers__` / prelude. Use for stable, lifetime-
+	 * of-the-worker bindings (e.g. browser's `page`, `browser`). Per-run scope should be set
+	 * via `setRunScope()` instead.
+	 */
+	extraGlobals?: Record<string, unknown>;
+	/**
+	 * On-disk roots the helpers substitute for internal-URL schemes (e.g.
+	 * `{ local: "/…/artifacts/local" }`). Stable for the worker's lifetime.
+	 */
+	localRoots?: Record<string, string>;
+}
+
+// Strict base64: characters from the standard alphabet plus optional `=` padding, and a
+// length that is a multiple of four. URL-safe base64 and embedded whitespace are not
+// accepted — the Anthropic API only honors strict base64 in image sources.
+const BASE64_STRICT_RE = /^[A-Za-z0-9+/]+={0,2}$/;
+const DECIMAL_CSV_RE = /^\d{1,3}(?:,\d{1,3})*$/;
+
+function isStrictBase64(s: string): boolean {
+	if (s.length === 0 || s.length % 4 !== 0) return false;
+	return BASE64_STRICT_RE.test(s);
+}
+
+/**
+ * Normalize the `data` field of an `{ type: "image", data, mimeType }` display payload
+ * into strict base64. Accepts:
+ *   - already-valid base64 strings (passed through verbatim)
+ *   - `Uint8Array` / `Buffer` / `ArrayBuffer` / typed array views
+ *   - `{ type: "Buffer", data: number[] }` (the shape Node serializes Buffers to via
+ *     `JSON.stringify`)
+ *   - decimal-CSV byte strings (the output of `uint8array.toString("base64")`, which
+ *     silently ignores the encoding argument and returns `Array.prototype.toString` —
+ *     a footgun for callers expecting `Buffer.toString` semantics)
+ * Returns `null` if no recovery is possible.
+ */
+function coerceImageBase64(data: unknown): string | null {
+	if (typeof data === "string") {
+		if (isStrictBase64(data)) return data;
+		if (DECIMAL_CSV_RE.test(data)) {
+			const parts = data.split(",");
+			const bytes = new Uint8Array(parts.length);
+			for (let i = 0; i < parts.length; i++) {
+				const n = Number(parts[i]);
+				if (!Number.isInteger(n) || n < 0 || n > 255) return null;
+				bytes[i] = n;
+			}
+			return Buffer.from(bytes).toString("base64");
+		}
+		return null;
+	}
+	if (data instanceof Uint8Array) return Buffer.from(data).toString("base64");
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("base64");
+	if (ArrayBuffer.isView(data)) {
+		const view = data as ArrayBufferView;
+		return Buffer.from(view.buffer, view.byteOffset, view.byteLength).toString("base64");
+	}
+	if (data && typeof data === "object") {
+		const obj = data as { type?: unknown; data?: unknown };
+		if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+			const arr = obj.data as unknown[];
+			const bytes = new Uint8Array(arr.length);
+			for (let i = 0; i < arr.length; i++) {
+				const n = arr[i];
+				if (typeof n !== "number" || !Number.isInteger(n) || n < 0 || n > 255) return null;
+				bytes[i] = n;
+			}
+			return Buffer.from(bytes).toString("base64");
+		}
+	}
+	return null;
+}
+
+function describeDataType(data: unknown): string {
+	if (data === null) return "null";
+	if (data instanceof Uint8Array) return "Uint8Array";
+	if (data instanceof ArrayBuffer) return "ArrayBuffer";
+	if (ArrayBuffer.isView(data)) return data.constructor.name;
+	if (typeof data === "string") return `string(${data.length})`;
+	return typeof data;
+}
+
+/**
+ * Shared JS runtime for the eval worker and the browser tab worker. Owns the prelude,
+ * helper bag, console bridge, and indirect-eval execution. Emits text/display/tool-call
+ * back through `RuntimeHooks` that the embedder supplies — wire format is the embedder's
+ * concern.
+ */
+export class JsRuntime {
+	readonly helpers: HelperBundle;
+	#cwd: string;
+	readonly sessionId: string;
+	#env: Map<string, string>;
+	#als = new AsyncLocalStorage<RunContext>();
+	#moduleLoader: LocalModuleLoader;
+	#localRoots: Record<string, string>;
+
+	constructor(opts: RuntimeOptions) {
+		this.#cwd = opts.initialCwd;
+		this.sessionId = opts.sessionId;
+		this.#env = new Map();
+		this.#moduleLoader = new LocalModuleLoader(this.sessionId);
+		this.#localRoots = opts.localRoots ?? {};
+		this.helpers = createHelpers({
+			cwd: () => this.#activeCwd(),
+			env: this.#env,
+			localRoots: () => this.#localRoots,
+			emitStatus: event => this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event }),
+		});
+		this.#install(opts.extraGlobals);
+	}
+
+	get cwd(): string {
+		return this.#cwd;
+	}
+
+	setCwd(cwd: string): void {
+		this.#cwd = cwd;
+		const session = (globalThis as { __omp_session__?: { cwd?: string } }).__omp_session__;
+		if (session) session.cwd = cwd;
+	}
+
+	/**
+	 * Install per-run globals. Intended for run-scoped state (browser's `tab`, `display`
+	 * overrides, etc.). Overwrites previous assignments — caller is responsible for any
+	 * cleanup it wants.
+	 */
+	setRunScope(scope: Record<string, unknown>): void {
+		Object.assign(globalThis, scope);
+	}
+
+	async run(
+		code: string,
+		filename: string | undefined,
+		hooks: RuntimeHooks,
+		options: { runId?: string; cwd?: string } = {},
+	): Promise<unknown> {
+		const context: RunContext = {
+			runId: options.runId ?? crypto.randomUUID(),
+			hooks,
+			cwd: options.cwd ?? this.#cwd,
+			finalExpressionSet: false,
+			finalExpressionValue: undefined,
+		};
+		return await this.#als.run(context, async () => {
+			const wrapped = await wrapCode(code);
+			const value = indirectEval(wrapped.source, filename);
+			if (wrapped.finalExpressionReturned) {
+				const awaited = await awaitMaybePromise(value);
+				if (context.finalExpressionSet) {
+					const finalValue = context.finalExpressionValue;
+					context.finalExpressionSet = false;
+					context.finalExpressionValue = undefined;
+					return await awaitMaybePromise(finalValue);
+				}
+				return awaited;
+			}
+			return await awaitMaybePromise(value);
+		});
+	}
+
+	displayValue(value: unknown, hooks: RuntimeHooks | undefined = this.#als.getStore()?.hooks): void {
+		if (value === undefined) return;
+		if (!hooks) {
+			logger.warn("js runtime display called outside an active run");
+			return;
+		}
+		if (value && typeof value === "object") {
+			const record = value as Record<string, unknown>;
+			if (record.type === "image" && typeof record.mimeType === "string") {
+				const data = coerceImageBase64(record.data);
+				if (data !== null) {
+					hooks.onDisplay({ type: "image", data, mimeType: record.mimeType });
+					return;
+				}
+				logger.warn("js displayValue: dropping image with unrecognized data shape", {
+					mimeType: record.mimeType,
+					dataType: describeDataType(record.data),
+				});
+				hooks.onText(
+					`[display: image dropped — \`data\` must be a base64 string, Uint8Array/Buffer, or ArrayBuffer; got ${describeDataType(record.data)}]\n`,
+				);
+				return;
+			}
+			try {
+				hooks.onDisplay({ type: "json", data: structuredClone(value) });
+			} catch (err) {
+				logger.debug("js displayValue: value is not structured-cloneable, falling back to text", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+				hooks.onText(`${Object.prototype.toString.call(value)}\n`);
+			}
+			return;
+		}
+		hooks.onText(`${String(value)}\n`);
+	}
+
+	#activeCwd(): string {
+		return this.#als.getStore()?.cwd ?? this.#cwd;
+	}
+
+	#activeHooks(action: string): RuntimeHooks | undefined {
+		const hooks = this.#als.getStore()?.hooks;
+		if (!hooks) {
+			logger.warn("js runtime helper called outside an active run", { action });
+		}
+		return hooks;
+	}
+
+	#activeRequire(moduleUrlOrPath?: string): NodeJS.Require {
+		return this.#moduleLoader.requireForFile(moduleUrlOrPath, this.#activeCwd());
+	}
+
+	#moduleFilename(moduleUrlOrPath?: string): string {
+		return this.#moduleLoader.filenameForUrl(moduleUrlOrPath) ?? path.join(this.#activeCwd(), "[eval]");
+	}
+
+	#moduleDirname(moduleUrlOrPath?: string): string {
+		return this.#moduleLoader.dirnameForUrl(moduleUrlOrPath, this.#activeCwd());
+	}
+
+	#buildDynamicRequire(): NodeJS.Require {
+		const dynamicRequire = ((id: string) => this.#activeRequire()(id)) as NodeJS.Require;
+		const resolve = ((id: string, options?: { paths?: string[] }) =>
+			this.#activeRequire().resolve(id, options)) as NodeJS.Require["resolve"] & {
+			paths(request: string): string[] | null;
+		};
+		resolve.paths = request => this.#activeRequire().resolve.paths(request);
+		Object.defineProperties(dynamicRequire, {
+			resolve: { value: resolve, configurable: true },
+			cache: { get: () => this.#activeRequire().cache, configurable: true },
+			extensions: { get: () => this.#activeRequire().extensions, configurable: true },
+			main: { get: () => this.#activeRequire().main, configurable: true },
+		});
+		return dynamicRequire;
+	}
+
+	#install(extraGlobals: Record<string, unknown> | undefined): void {
+		const injected: Record<string, unknown> = {
+			__omp_session__: { cwd: this.#cwd, sessionId: this.sessionId },
+			__omp_helpers__: this.helpers,
+			__omp_call_tool__: async (name: string, args: unknown) => {
+				const hooks = this.#activeHooks("tool");
+				if (!hooks) return undefined;
+				return await hooks.callTool(name, args);
+			},
+			__omp_import__: async (source: string, options?: ImportCallOptions) => {
+				const resolved = await this.#moduleLoader.resolveForRun(this.#activeCwd(), source);
+				if (resolved.mode === "local") return resolved.value;
+				const target = resolved.target;
+				return options !== undefined ? await import(target, options) : await import(target);
+			},
+			__omp_import_from__: async (moduleUrl: string, source: string, options?: ImportCallOptions) => {
+				const resolved = await this.#moduleLoader.resolveForModule(moduleUrl, source, this.#activeCwd());
+				if (resolved.mode === "local") return resolved.value;
+				const target = resolved.target;
+				return options !== undefined ? await import(target, options) : await import(target);
+			},
+			__omp_get_require__: (moduleUrl?: string) => this.#activeRequire(moduleUrl),
+			__omp_get_filename__: (moduleUrl?: string) => this.#moduleFilename(moduleUrl),
+			__omp_get_dirname__: (moduleUrl?: string) => this.#moduleDirname(moduleUrl),
+			__omp_emit_status__: (op: string, data: Record<string, unknown> = {}) => {
+				const event: JsStatusEvent = { op, ...data };
+				this.#activeHooks("emitStatus")?.onDisplay({ type: "status", event });
+			},
+			__omp_log__: (level: string, ...args: unknown[]) => {
+				const prefix = level === "error" ? "[error] " : level === "warn" ? "[warn] " : "";
+				const text = `${prefix}${formatConsoleArgs(args)}`;
+				this.#activeHooks("log")?.onText(text.endsWith("\n") ? text : `${text}\n`);
+			},
+			__omp_table__: (...args: unknown[]) => {
+				const hooks = this.#activeHooks("table");
+				if (!hooks) return;
+				let buffer = "";
+				const stream = new Writable({
+					write(chunk, _enc, cb) {
+						buffer += typeof chunk === "string" ? chunk : (chunk as Buffer).toString("utf8");
+						cb();
+					},
+				});
+				const tableConsole = new Console({ stdout: stream, colorMode: false });
+				(tableConsole.table as (...a: unknown[]) => void)(...args);
+				hooks.onText(buffer.endsWith("\n") ? buffer : `${buffer}\n`);
+			},
+			__omp_display__: (value: unknown) => this.displayValue(value),
+			__omp_set_final_expr__: (value: unknown) => {
+				const context = this.#als.getStore();
+				if (!context) {
+					logger.warn("js runtime final expression set outside an active run");
+					return;
+				}
+				context.finalExpressionSet = true;
+				context.finalExpressionValue = value;
+			},
+			webcrypto: crypto,
+			// `process` is intentionally not overridden — user code gets the host worker's real
+			// `process` object. Subsetting it caused segfaults in workers that share state with
+			// puppeteer/worker_threads internals.
+			require: this.#buildDynamicRequire(),
+			createRequire,
+			fs,
+		};
+		Object.assign(globalThis, injected, extraGlobals ?? {});
+		// Prelude assigns console bridge + short aliases (`read`, `write`, `tool`, `display`, ...)
+		// onto globalThis. Must run after helpers are in place.
+		indirectEval(JAVASCRIPT_PRELUDE_SOURCE);
+	}
+}
+
+function formatConsoleArgs(args: unknown[]): string {
+	return args
+		.map(arg => (typeof arg === "string" ? arg : util.inspect(arg, { depth: 6, colors: false, breakLength: 120 })))
+		.join(" ");
+}

package/src/eval/js/shared/types.ts

@@ -0,0 +1,18 @@
+/**
+ * Structured status payload emitted by helpers (`read`, `write`, `tree`, etc.) and the
+ * tool-call bridge. Surfaces to the model as part of `displays` so it has machine-readable
+ * context about what side effects happened.
+ */
+export interface JsStatusEvent {
+	op: string;
+	[key: string]: unknown;
+}
+
+/**
+ * One unit of structured output from a JS eval cell. `text` chunks flow through a separate
+ * channel.
+ */
+export type JsDisplayOutput =
+	| { type: "json"; data: unknown }
+	| { type: "image"; data: string; mimeType: string }
+	| { type: "status"; event: JsStatusEvent };

package/src/eval/js/tool-bridge.ts

@@ -0,0 +1,162 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ToolSession } from "../../tools";
+import { ToolError } from "../../tools/tool-errors";
+import { EVAL_AGENT_BRIDGE_NAME, runEvalAgent } from "../agent-bridge";
+import { EVAL_BUDGET_BRIDGE_NAME, type EvalBudgetResult, runEvalBudget } from "../budget-bridge";
+import { EVAL_COMPLETION_BRIDGE_NAME, runEvalCompletion } from "../completion-bridge";
+import { EVAL_CONCURRENCY_BRIDGE_NAME, type EvalConcurrencyResult, runEvalConcurrency } from "../concurrency-bridge";
+import type { JsStatusEvent } from "./shared/types";
+
+export type { JsStatusEvent } from "./shared/types";
+
+interface ToolBridgeOptions {
+	session: ToolSession;
+	signal?: AbortSignal;
+	emitStatus?: (event: JsStatusEvent) => void;
+}
+
+type ToolValue =
+	| string
+	| EvalBudgetResult
+	| EvalConcurrencyResult
+	| {
+			text: string;
+			details?: unknown;
+			images?: Array<{ mimeType: string; data: string }>;
+			hasError?: boolean;
+	  };
+function toolResultHasError(result: AgentToolResult): boolean {
+	if ((result as { isError?: unknown }).isError === true) {
+		return true;
+	}
+	if (!(result.details && typeof result.details === "object")) {
+		return false;
+	}
+	return (result.details as { isError?: unknown }).isError === true;
+}
+
+function getTool(session: ToolSession, name: string): AgentTool {
+	const tool = session.getToolByName?.(name);
+	if (!tool) {
+		throw new ToolError(`Unknown tool from js runtime: ${name}`);
+	}
+	return tool;
+}
+
+function normalizeArgs(args: unknown): unknown {
+	if (!args || typeof args !== "object" || Array.isArray(args)) {
+		return args;
+	}
+	const record = { ...(args as Record<string, unknown>) };
+	if (record._i === undefined) {
+		record._i = "js prelude";
+	}
+	return record;
+}
+
+function summarizeToolResult(
+	name: string,
+	args: unknown,
+	result: AgentToolResult,
+	text: string,
+	hasError: boolean,
+): JsStatusEvent {
+	const record = (args && typeof args === "object" ? (args as Record<string, unknown>) : {}) as Record<
+		string,
+		unknown
+	>;
+	const details = (
+		result.details && typeof result.details === "object" ? (result.details as Record<string, unknown>) : {}
+	) as Record<string, unknown>;
+	const withError = (event: JsStatusEvent): JsStatusEvent =>
+		hasError ? { ...event, hasError: true, error: text.slice(0, 500) } : event;
+
+	switch (name) {
+		case "read":
+			return withError({ op: "read", path: record.path, chars: text.length, preview: text.slice(0, 500) });
+		case "write":
+			return withError({
+				op: "write",
+				path: record.path,
+				chars: typeof record.content === "string" ? record.content.length : 0,
+			});
+		case "grep":
+			return withError({
+				op: "grep",
+				pattern: record.pattern,
+				path: record.path,
+				count: details.matchCount ?? undefined,
+			});
+		case "find":
+			return withError({
+				op: "find",
+				pattern: record.pattern,
+				count: details.fileCount ?? undefined,
+				matches: Array.isArray(details.files) ? details.files.slice(0, 20) : undefined,
+			});
+		case "bash":
+			return withError({
+				op: "run",
+				cmd: record.command,
+				code: typeof details.exitCode === "number" ? details.exitCode : undefined,
+				output: text.slice(0, 500),
+			});
+		default:
+			return withError({ op: name, chars: text.length });
+	}
+}
+
+export async function callSessionTool(name: string, args: unknown, options: ToolBridgeOptions): Promise<ToolValue> {
+	if (name === EVAL_COMPLETION_BRIDGE_NAME) {
+		return await runEvalCompletion(args, options);
+	}
+	if (name === EVAL_AGENT_BRIDGE_NAME) {
+		return await runEvalAgent(args, options);
+	}
+	if (name === EVAL_BUDGET_BRIDGE_NAME) {
+		return await runEvalBudget(args, options);
+	}
+	if (name === EVAL_CONCURRENCY_BRIDGE_NAME) {
+		return runEvalConcurrency(args, options);
+	}
+	const tool = getTool(options.session, name);
+	const normalizedArgs = normalizeArgs(args);
+	const toolCallId = `js-${name}-${crypto.randomUUID()}`;
+	try {
+		const result = await tool.execute(toolCallId, normalizedArgs, options.signal);
+		const textBlocks = result.content.filter(
+			(content): content is { type: "text"; text: string } =>
+				content.type === "text" && typeof content.text === "string",
+		);
+		const imageBlocks = result.content.filter(
+			(content): content is { type: "image"; mimeType: string; data: string } =>
+				content.type === "image" && typeof content.mimeType === "string" && typeof content.data === "string",
+		);
+		const text = textBlocks.map(block => block.text).join("");
+		const hasError = toolResultHasError(result);
+		options.emitStatus?.(summarizeToolResult(name, normalizedArgs, result, text, hasError));
+		if (result.details === undefined && imageBlocks.length === 0 && !hasError) {
+			return text;
+		}
+		const value: Exclude<ToolValue, string> = {
+			text,
+			details: result.details,
+		};
+		if (imageBlocks.length > 0) {
+			value.images = imageBlocks.map(block => ({
+				mimeType: block.mimeType,
+				data: block.data,
+			}));
+		}
+		if (hasError) {
+			value.hasError = true;
+		}
+		return value;
+	} catch (error) {
+		options.emitStatus?.({
+			op: name,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		throw error;
+	}
+}

package/src/eval/js/worker-core.ts

@@ -0,0 +1,132 @@
+import { ToolError } from "../../tools/tool-errors";
+import { JsRuntime, type RuntimeHooks } from "./shared/runtime";
+import type { RunErrorPayload, SessionSnapshot, ToolReply, Transport, WorkerInbound } from "./worker-protocol";
+
+interface PendingTool {
+	runId: string;
+	resolve(value: unknown): void;
+	reject(error: Error): void;
+}
+
+interface ActiveRun {
+	runId: string;
+	pendingTools: Map<string, PendingTool>;
+}
+
+function errorPayload(error: unknown): RunErrorPayload {
+	if (error instanceof Error) {
+		return {
+			name: error.name,
+			message: error.message,
+			stack: error.stack,
+			isAbort: error.name === "AbortError" || error.name === "ToolAbortError",
+			isToolError: error.name === "ToolError" || error instanceof ToolError,
+		};
+	}
+	return { message: String(error) };
+}
+
+function errorFromPayload(payload: RunErrorPayload): Error {
+	const ctor = payload.isToolError ? ToolError : Error;
+	const error = new ctor(payload.message);
+	if (payload.name) error.name = payload.name;
+	if (payload.stack) error.stack = payload.stack;
+	return error;
+}
+
+export class WorkerCore {
+	#transport: Transport;
+	#runtime: JsRuntime | null = null;
+	#runs = new Map<string, ActiveRun>();
+	#unsubscribe: () => void;
+
+	constructor(transport: Transport) {
+		this.#transport = transport;
+		this.#unsubscribe = transport.onMessage(msg => this.#handle(msg));
+		transport.send({ type: "ready" });
+	}
+
+	#handle(msg: WorkerInbound): void {
+		switch (msg.type) {
+			case "init":
+				this.#ensureRuntime(msg.snapshot);
+				return;
+			case "run":
+				void this.#runOne(msg.runId, msg.code, msg.filename, msg.snapshot);
+				return;
+			case "tool-reply":
+				this.#deliverToolReply(msg.id, msg.reply);
+				return;
+			case "close":
+				this.#close();
+				return;
+		}
+	}
+
+	#ensureRuntime(snapshot: SessionSnapshot): JsRuntime {
+		if (this.#runtime) {
+			this.#runtime.setCwd(snapshot.cwd);
+			return this.#runtime;
+		}
+		this.#runtime = new JsRuntime({
+			initialCwd: snapshot.cwd,
+			sessionId: snapshot.sessionId,
+			localRoots: snapshot.localRoots,
+		});
+		return this.#runtime;
+	}
+
+	async #runOne(runId: string, code: string, filename: string, snapshot: SessionSnapshot): Promise<void> {
+		const runtime = this.#ensureRuntime(snapshot);
+		runtime.setCwd(snapshot.cwd);
+		const active: ActiveRun = { runId, pendingTools: new Map() };
+		this.#runs.set(runId, active);
+		const hooks: RuntimeHooks = {
+			onText: chunk => this.#transport.send({ type: "text", runId, chunk }),
+			onDisplay: output => this.#transport.send({ type: "display", runId, output }),
+			callTool: (name, args) => this.#callTool(active, name, args),
+		};
+		try {
+			const value = await runtime.run(code, filename, hooks, { runId, cwd: snapshot.cwd });
+			runtime.displayValue(value, hooks);
+			this.#transport.send({ type: "result", runId, ok: true });
+		} catch (error) {
+			this.#transport.send({ type: "result", runId, ok: false, error: errorPayload(error) });
+		} finally {
+			this.#runs.delete(runId);
+		}
+	}
+
+	async #callTool(active: ActiveRun, name: string, args: unknown): Promise<unknown> {
+		const id = `tc-${active.runId}-${crypto.randomUUID()}`;
+		const { promise, resolve, reject } = Promise.withResolvers<unknown>();
+		active.pendingTools.set(id, { runId: active.runId, resolve, reject });
+		this.#transport.send({ type: "tool-call", id, runId: active.runId, name, args });
+		return await promise;
+	}
+
+	#deliverToolReply(id: string, reply: ToolReply): void {
+		for (const active of this.#runs.values()) {
+			const pending = active.pendingTools.get(id);
+			if (!pending) continue;
+			active.pendingTools.delete(id);
+			if (reply.ok) pending.resolve(reply.value);
+			else pending.reject(errorFromPayload(reply.error));
+			return;
+		}
+	}
+
+	#close(): void {
+		for (const active of this.#runs.values()) {
+			for (const pending of active.pendingTools.values()) {
+				pending.reject(new ToolError("JS worker closed"));
+			}
+			active.pendingTools.clear();
+		}
+		this.#runs.clear();
+		this.#runtime = null;
+		this.#transport.send({ type: "closed" });
+		this.#unsubscribe();
+		this.#transport.close();
+	}
+}

package/src/eval/js/worker-entry.ts

@@ -0,0 +1,30 @@
+import { parentPort } from "node:worker_threads";
+import { WorkerCore } from "./worker-core";
+import type { Transport, WorkerInbound, WorkerOutbound } from "./worker-protocol";
+
+if (!parentPort) throw new Error("js worker-entry: missing parentPort");
+
+const port = parentPort;
+const transport: Transport = {
+	send: (msg: WorkerOutbound) => port.postMessage(msg),
+	onMessage: handler => {
+		const wrap = (data: unknown): void => handler(data as WorkerInbound);
+		port.on("message", wrap);
+		return () => port.off("message", wrap);
+	},
+	close: () => {
+		try {
+			port.close();
+		} catch {
+			// Already closed.
+		}
+
+		// `parentPort.close()` only disconnects the channel in Bun; it does not
+		// make the Worker emit `close` or reap ref'ed user handles. Exit from
+		// inside the worker after `WorkerCore` has sent the `closed` ack so the
+		// host can observe real worker exit without calling `Worker.terminate()`.
+		setTimeout(() => process.exit(0), 0);
+	},
+};
+
+new WorkerCore(transport);