@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/eval/__tests__/js-context-manager.test.ts

@@ -0,0 +1,241 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { TempDir } from "@prometheus-ai/utils";
+import { Settings } from "../../config/settings";
+import type { ToolSession } from "../../tools";
+import { disposeAllVmContexts } from "../js/context-manager";
+import { executeJs } from "../js/executor";
+
+const originalWorker = globalThis.Worker;
+
+interface FakeWorkerStats {
+	closeRequests: number;
+	terminateCalls: number;
+}
+
+interface FakeWorkerBehavior {
+	exitOnClose: boolean;
+	settleRuns: boolean;
+}
+
+function makeSession(cwd: string): ToolSession {
+	return {
+		cwd,
+		hasUI: false,
+		settings: Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+		}),
+		taskDepth: 0,
+		enableLsp: true,
+		getSessionFile: () => null,
+		getSessionSpawns: () => "*",
+		getActiveModelString: () => "p/active",
+		getModelString: () => "p/fallback",
+		getArtifactsDir: () => null,
+		getSessionId: () => "test-session",
+		getEvalSessionId: () => "test-eval-session",
+	};
+}
+
+async function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
+	let timeout: NodeJS.Timeout | undefined;
+	try {
+		return await Promise.race([
+			promise,
+			new Promise<never>((_, reject) => {
+				timeout = setTimeout(() => reject(new Error(`${label} timed out`)), ms);
+			}),
+		]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+
+async function waitForRealWorkerExitAfterClose(cwd: string): Promise<void> {
+	const worker = new originalWorker(new URL("../js/worker-entry.ts", import.meta.url).href, { type: "module" });
+	const ready = Promise.withResolvers<void>();
+	const runComplete = Promise.withResolvers<void>();
+	const closedAck = Promise.withResolvers<void>();
+	const workerClosed = Promise.withResolvers<void>();
+	const runId = `keep-alive:${crypto.randomUUID()}`;
+	const snapshot = { cwd, sessionId: `worker-exit:${crypto.randomUUID()}` };
+
+	worker.addEventListener("message", event => {
+		const msg = event.data as { type?: string; runId?: string; ok?: boolean };
+		if (msg.type === "ready") ready.resolve();
+		else if (msg.type === "result" && msg.runId === runId && msg.ok) runComplete.resolve();
+		else if (msg.type === "closed") closedAck.resolve();
+	});
+	worker.addEventListener("close", () => workerClosed.resolve());
+
+	try {
+		await withTimeout(ready.promise, 1_000, "worker ready");
+		worker.postMessage({
+			type: "run",
+			runId,
+			code: "globalThis.__keepAlive = setInterval(() => {}, 1000);\nundefined;",
+			filename: "keep-alive.js",
+			snapshot,
+		});
+		await withTimeout(runComplete.promise, 1_000, "worker run");
+		worker.postMessage({ type: "close" });
+		await withTimeout(closedAck.promise, 1_000, "worker closed ack");
+		await withTimeout(workerClosed.promise, 1_000, "worker close event");
+	} finally {
+		worker.terminate();
+	}
+}
+
+function installFakeWorker(stats: FakeWorkerStats, behavior: FakeWorkerBehavior): void {
+	class FakeWorker {
+		#messageListeners = new Set<(event: MessageEvent) => void>();
+		#closeListeners = new Set<(event: Event) => void>();
+		#readyQueued = false;
+		#exited = false;
+
+		postMessage(message: unknown): void {
+			if (!message || typeof message !== "object") return;
+			const typed = message as { type?: string; runId?: string };
+			if (typed.type === "run" && typed.runId && behavior.settleRuns) {
+				queueMicrotask(() => this.#emitMessage({ type: "result", runId: typed.runId, ok: true }));
+				return;
+			}
+			if (typed.type === "close") {
+				stats.closeRequests++;
+				queueMicrotask(() => {
+					this.#emitMessage({ type: "closed" });
+					if (behavior.exitOnClose) this.#emitClose();
+				});
+			}
+		}
+
+		addEventListener(type: string, listener: (event: MessageEvent | Event) => void): void {
+			if (type === "close") {
+				this.#closeListeners.add(listener as (event: Event) => void);
+				return;
+			}
+			if (type !== "message") return;
+			this.#messageListeners.add(listener as (event: MessageEvent) => void);
+			if (!this.#readyQueued) {
+				this.#readyQueued = true;
+				queueMicrotask(() => this.#emitMessage({ type: "ready" }));
+			}
+		}
+
+		removeEventListener(type: string, listener: (event: MessageEvent | Event) => void): void {
+			if (type === "close") {
+				this.#closeListeners.delete(listener as (event: Event) => void);
+				return;
+			}
+			if (type !== "message") return;
+			this.#messageListeners.delete(listener as (event: MessageEvent) => void);
+		}
+
+		terminate(): void {
+			stats.terminateCalls++;
+			this.#emitClose();
+		}
+
+		#emitMessage(data: unknown): void {
+			const event = new MessageEvent("message", { data });
+			for (const listener of this.#messageListeners) listener(event);
+		}
+
+		#emitClose(): void {
+			if (this.#exited) return;
+			this.#exited = true;
+			const event = new Event("close");
+			for (const listener of this.#closeListeners) listener(event);
+		}
+	}
+
+	Object.defineProperty(globalThis, "Worker", {
+		configurable: true,
+		writable: true,
+		value: FakeWorker as unknown as typeof Worker,
+	});
+}
+
+describe("JavaScript eval worker lifecycle", () => {
+	afterEach(async () => {
+		await disposeAllVmContexts();
+		Object.defineProperty(globalThis, "Worker", {
+			configurable: true,
+			writable: true,
+			value: originalWorker,
+		});
+	});
+
+	it("exits a real worker on graceful close even with ref'ed user handles", async () => {
+		using tempDir = TempDir.createSync("@prometheus-js-worker-real-close-");
+
+		await waitForRealWorkerExitAfterClose(tempDir.path());
+	});
+
+	it("waits for the worker to close on reset instead of force-terminating it", async () => {
+		using tempDir = TempDir.createSync("@prometheus-js-worker-close-");
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: true, settleRuns: true });
+
+		const session = makeSession(tempDir.path());
+		const sessionId = `js-close:${crypto.randomUUID()}`;
+
+		const first = await executeJs("globalThis.marker = 1;", { cwd: tempDir.path(), sessionId, session });
+		expect(first.exitCode).toBe(0);
+
+		const second = await executeJs("globalThis.marker = 2;", {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			reset: true,
+		});
+		expect(second.exitCode).toBe(0);
+		expect(stats.closeRequests).toBe(1);
+		expect(stats.terminateCalls).toBe(0);
+	});
+
+	it("terminates when close is acknowledged but the worker does not exit", async () => {
+		using tempDir = TempDir.createSync("@prometheus-js-worker-close-hung-");
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: false, settleRuns: true });
+
+		const session = makeSession(tempDir.path());
+		const sessionId = `js-close-hung:${crypto.randomUUID()}`;
+
+		const first = await executeJs("globalThis.marker = 1;", { cwd: tempDir.path(), sessionId, session });
+		expect(first.exitCode).toBe(0);
+
+		const second = await executeJs("globalThis.marker = 2;", {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			reset: true,
+		});
+		expect(second.exitCode).toBe(0);
+		expect(stats.closeRequests).toBe(1);
+		expect(stats.terminateCalls).toBe(1);
+	});
+
+	it("force-terminates instead of closing when an in-flight run is aborted", async () => {
+		using tempDir = TempDir.createSync("@prometheus-js-worker-abort-");
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: true, settleRuns: false });
+
+		const session = makeSession(tempDir.path());
+		const sessionId = `js-abort:${crypto.randomUUID()}`;
+		const controller = new AbortController();
+		const resultPromise = executeJs("globalThis.neverFinishes = true;", {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			signal: controller.signal,
+		});
+		setTimeout(() => controller.abort(new DOMException("Execution aborted", "AbortError")), 0);
+
+		const result = await resultPromise;
+		expect(result.cancelled).toBe(true);
+		expect(stats.closeRequests).toBe(0);
+		expect(stats.terminateCalls).toBe(1);
+	});
+});

package/src/eval/__tests__/llm-bridge.test.ts

@@ -3,6 +3,8 @@ import * as path from "node:path";
 import type { Api, AssistantMessage, Model } from "@prometheus-ai/ai";
 import * as ai from "@prometheus-ai/ai";
 import { Effort } from "@prometheus-ai/ai";
+import { buildModel } from "@prometheus-ai/catalog/build";
+import type { ModelSpec } from "@prometheus-ai/catalog/types";
 import { TempDir } from "@prometheus-ai/utils";
 import type { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
@@ -15,8 +17,8 @@ import { executeJs } from "../js/executor";
 import { runEvalLlm } from "../llm-bridge";
 import { disposeAllKernelSessions, executePython } from "../py/executor";
 
-function makeModel(provider: string, id: string, extra: Partial<Model<Api>> = {}): Model<Api> {
-	return {
+function makeModel(provider: string, id: string, extra: Partial<ModelSpec<Api>> = {}): Model<Api> {
+	return buildModel({
 		id,
 		name: id,
 		api: "openai-responses",
@@ -28,7 +30,7 @@ function makeModel(provider: string, id: string, extra: Partial<Model<Api>> = {}
 		contextWindow: 128000,
 		maxTokens: 4096,
 		...extra,
-	} as Model<Api>;
+	});
 }
 
 const SMOL = makeModel("p", "smol");
@@ -37,7 +39,7 @@ const SLOW = makeModel("p", "slow");
 const REASONING_SLOW = makeModel("p", "slow", {
 	api: "anthropic-messages",
 	reasoning: true,
-	thinking: { minLevel: Effort.Low, maxLevel: Effort.High, mode: "anthropic-adaptive" },
+	thinking: { mode: "anthropic-adaptive", efforts: [Effort.Low, Effort.Medium, Effort.High] },
 });
 
 interface SessionOptions {

package/src/eval/__tests__/shared-executors.test.ts

@@ -1,19 +1,15 @@
 import { afterAll, afterEach, describe, expect, it, vi } from "bun:test";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { AssistantMessage } from "@prometheus-ai/ai";
 import { TempDir } from "@prometheus-ai/utils";
 import type { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
-import type { LoadExtensionsResult } from "../../extensibility/extensions/types";
-import type { CreateAgentSessionOptions, CreateAgentSessionResult } from "../../sdk";
-import * as sdkModule from "../../sdk";
-import type { AgentSession, AgentSessionEvent, PromptOptions } from "../../session/agent-session";
 import { TaskTool } from "../../task";
 import * as discoveryModule from "../../task/discovery";
-import type { AgentDefinition, TaskParams } from "../../task/types";
+import type { ExecutorOptions } from "../../task/executor";
+import * as taskExecutor from "../../task/executor";
+import type { AgentDefinition, SingleResult, TaskParams } from "../../task/types";
 import type { ToolSession } from "../../tools";
-import { EventBus } from "../../utils/event-bus";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
 import { disposeAllKernelSessions, executePython } from "../py/executor";
@@ -54,70 +50,6 @@ function createBridgeToolSession(resultText: string, calls: unknown[]): ToolSess
 	return { getToolByName: (name: string) => tools.get(name) } as unknown as ToolSession;
 }
 
-function assistantStopMessage(text: string): AssistantMessage {
-	return {
-		role: "assistant",
-		content: text ? [{ type: "text", text }] : [],
-		api: "openai-responses",
-		provider: "openai",
-		model: "mock",
-		usage: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 0,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-		},
-		stopReason: "stop",
-		timestamp: Date.now(),
-	};
-}
-
-function createYieldingSubagentSession(onPrompt: () => Promise<void>): AgentSession {
-	const listeners: Array<(event: AgentSessionEvent) => void> = [];
-	const state = { messages: [] as AssistantMessage[] };
-	const emit = (event: AgentSessionEvent) => {
-		for (const listener of listeners) listener(event);
-	};
-	return {
-		state,
-		agent: { state: { systemPrompt: ["test"] } },
-		model: undefined,
-		extensionRunner: undefined,
-		sessionManager: {
-			appendSessionInit: () => {},
-		},
-		getActiveToolNames: () => ["eval", "yield"],
-		setActiveToolsByName: async () => {},
-		subscribe: (listener: (event: AgentSessionEvent) => void) => {
-			listeners.push(listener);
-			return () => {
-				const index = listeners.indexOf(listener);
-				if (index >= 0) listeners.splice(index, 1);
-			};
-		},
-		prompt: async (_text: string, _options?: PromptOptions) => {
-			await onPrompt();
-			state.messages.push(assistantStopMessage("done"));
-			emit({
-				type: "tool_execution_end",
-				toolCallId: "yield-call",
-				toolName: "yield",
-				result: {
-					content: [{ type: "text", text: "Result submitted." }],
-					details: { status: "success", data: { ok: true } },
-				},
-				isError: false,
-			});
-		},
-		waitForIdle: async () => {},
-		getLastAssistantMessage: () => state.messages[state.messages.length - 1],
-		abort: async () => {},
-		dispose: async () => {},
-	} as unknown as AgentSession;
-}
-
 const taskAgent: AgentDefinition = {
 	name: "task",
 	description: "Task agent",
@@ -128,7 +60,9 @@ const taskAgent: AgentDefinition = {
 
 const taskParams: TaskParams = {
 	agent: "task",
-	tasks: [{ id: "ReadEval", description: "Read eval state", assignment: "Read parent eval state." }],
+	id: "ReadEval",
+	description: "Read eval state",
+	assignment: "Read parent eval state.",
 };
 
 describe("shared eval executors", () => {
@@ -336,7 +270,7 @@ print("token" in globals())`,
 		const parentSession = createToolSession(tempDir.path(), sessionFile, evalSessionId);
 		let seenJs = "";
 		let seenPy = "";
-		let capturedOptions: CreateAgentSessionOptions | undefined;
+		let capturedOptions: ExecutorOptions | undefined;
 
 		await executeJs('globalThis.parentSecret = "hello-js";', {
 			sessionId: `js:${evalSessionId}`,
@@ -350,29 +284,37 @@ print("token" in globals())`,
 		});
 
 		vi.spyOn(discoveryModule, "discoverAgents").mockResolvedValue({ agents: [taskAgent], projectAgentsDir: null });
-		vi.spyOn(sdkModule, "createAgentSession").mockImplementation(async (options = {}) => {
+		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
 			capturedOptions = options;
 			const inherited = options.parentEvalSessionId;
 			if (!inherited) throw new Error("Missing parent eval session id");
+			const jsResult = await executeJs("return globalThis.parentSecret;", {
+				sessionId: `js:${inherited}`,
+				session: parentSession,
+				sessionFile,
+			});
+			const pyResult = await executePython("print(parent_secret)", {
+				cwd: tempDir.path(),
+				sessionId: `python:${inherited}`,
+				sessionFile,
+			});
+			seenJs = jsResult.output.trim();
+			seenPy = pyResult.output.trim();
 			return {
-				session: createYieldingSubagentSession(async () => {
-					const jsResult = await executeJs("return globalThis.parentSecret;", {
-						sessionId: `js:${inherited}`,
-						session: parentSession,
-						sessionFile,
-					});
-					const pyResult = await executePython("print(parent_secret)", {
-						cwd: tempDir.path(),
-						sessionId: `python:${inherited}`,
-						sessionFile,
-					});
-					seenJs = jsResult.output.trim();
-					seenPy = pyResult.output.trim();
-				}),
-				extensionsResult: {} as unknown as LoadExtensionsResult,
-				setToolUIContext: () => {},
-				eventBus: new EventBus(),
-			} satisfies CreateAgentSessionResult;
+				index: options.index,
+				id: options.id,
+				agent: options.agent.name,
+				agentSource: options.agent.source,
+				task: options.task,
+				assignment: options.assignment,
+				exitCode: 0,
+				output: "done",
+				stderr: "",
+				truncated: false,
+				durationMs: 1,
+				tokens: 0,
+				requests: 1,
+			} satisfies SingleResult;
 		});
 
 		const tool = await TaskTool.create(parentSession);

package/src/eval/agent-bridge.ts

@@ -5,7 +5,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { prompt, Snowflake } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { resolveAgentModelPatterns } from "../config/model-resolver";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { MCPManager } from "../mcp/manager";
@@ -13,7 +13,7 @@ import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.m
 import * as taskDiscovery from "../task/discovery";
 import * as taskExecutor from "../task/executor";
 import { AgentOutputManager } from "../task/output-manager";
-import type { AgentDefinition, AgentProgress } from "../task/types";
+import type { AgentDefinition, AgentProgress, SingleResult } from "../task/types";
 import type { ToolSession } from "../tools";
 import { ToolError } from "../tools/tool-errors";
 import { withBridgeTimeoutPause } from "./bridge-timeout";
@@ -34,7 +34,6 @@ const agentArgsSchema = z.object({
 	prompt: z.string().min(1, "prompt must be a non-empty string"),
 	agentType: z.string().min(1).optional(),
 	model: z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).optional(),
-	context: z.string().optional(),
 	label: z.string().optional(),
 	schema: z.unknown().optional(),
 });
@@ -43,7 +42,6 @@ interface EvalAgentArgs {
 	prompt: string;
 	agentType?: string;
 	model?: string | string[];
-	context?: string;
 	label?: string;
 	schema?: unknown;
 }
@@ -111,7 +109,7 @@ function assertNotPlanMode(session: ToolSession): void {
 }
 
 function renderSubagentPrompt(assignment: string): string {
-	return prompt.render(subagentUserPromptTemplate, { assignment: assignment.trim(), independentMode: false });
+	return prompt.render(subagentUserPromptTemplate, { assignment: assignment.trim() });
 }
 
 function trimToUndefined(value: string | undefined): string | undefined {
@@ -135,20 +133,12 @@ function getOutputManager(session: ToolSession): AgentOutputManager {
 async function getArtifacts(session: ToolSession): Promise<{
 	sessionFile: string | null;
 	artifactsDir: string;
-	contextFile?: string;
 }> {
 	const sessionFile = session.getSessionFile();
 	const sessionArtifactsDir = sessionFile ? sessionFile.slice(0, -6) : null;
 	const artifactsDir = sessionArtifactsDir ?? path.join(os.tmpdir(), `prometheus-eval-agent-${Snowflake.next()}`);
 	await fs.mkdir(artifactsDir, { recursive: true });
-
-	const shouldWriteConversationContext = session.settings.get("irc.enabled") !== true;
-	const compactContext = shouldWriteConversationContext ? session.getCompactContext?.() : undefined;
-	if (!compactContext) return { sessionFile, artifactsDir };
-
-	const contextFile = path.join(artifactsDir, "context.md");
-	await Bun.write(contextFile, compactContext);
-	return { sessionFile, artifactsDir, contextFile };
+	return { sessionFile, artifactsDir };
 }
 
 function emitProgressStatus(emitStatus: ((event: JsStatusEvent) => void) | undefined, progress: AgentProgress): void {
@@ -173,6 +163,26 @@ function emitProgressStatus(emitStatus: ((event: JsStatusEvent) => void) | undef
 	});
 }
 
+/**
+ * Coalesce a subagent failure into a non-empty, human-meaningful error message.
+ *
+ * When the executor aborts a subagent (runtime limit, parent cancellation, …)
+ * the actionable explanation lives on `abortReason`, while `error`/`stderr`
+ * are routinely empty strings. Plain `??` coalescing stops at the empty string
+ * and ships an empty error through the bridge — Python then surfaces only the
+ * generic `bridge call '__agent__' failed`. See #2006.
+ */
+function buildSubagentFailureMessage(agentName: string, result: SingleResult): string {
+	const abortReason = trimToUndefined(result.abortReason);
+	if (result.aborted && abortReason) return abortReason;
+	return (
+		trimToUndefined(result.error) ??
+		trimToUndefined(result.stderr) ??
+		abortReason ??
+		`agent() subagent '${agentName}' failed.`
+	);
+}
+
 /**
  * Run a single subagent on behalf of an eval cell's `agent()` call.
  */
@@ -226,11 +236,10 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 	};
 	const parentArtifactManager = options.session.getArtifactManager?.() ?? undefined;
 	const mcpManager = options.session.mcpManager ?? MCPManager.instance();
-	const { sessionFile, artifactsDir, contextFile } = await getArtifacts(options.session);
+	const { sessionFile, artifactsDir } = await getArtifacts(options.session);
 	const outputManager = getOutputManager(options.session);
 	const id = await outputManager.allocate(outputIdBase(parsed.label, agentName));
 	const assignment = parsed.prompt.trim();
-	const context = trimToUndefined(parsed.context);
 	// Suspend eval timeout accounting while the subagent owns control. The
 	// timeout clock restarts once the bridge returns to the cell runtime.
 	const result = await withBridgeTimeoutPause(options.emitStatus, () =>
@@ -239,7 +248,6 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 			agent: effectiveAgent,
 			task: renderSubagentPrompt(assignment),
 			assignment,
-			context,
 			description: trimToUndefined(parsed.label),
 			index: 0,
 			id,
@@ -251,14 +259,24 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 			sessionFile,
 			persistArtifacts: Boolean(sessionFile),
 			artifactsDir,
-			contextFile,
-			enableLsp: (options.session.enableLsp ?? true) && options.session.settings.get("task.enableLsp"),
+			// Eval `agent()` subagents are short-lived programmatic helpers (data
+			// collection, structured output, parallel() fan-out). LSP server
+			// cold-start costs tens of seconds and is pure overhead here, so it is
+			// forced off regardless of the `task.enableLsp` setting — that knob only
+			// governs LSP-aware delegation through the `task` tool.
+			enableLsp: false,
 			signal: options.signal,
 			eventBus: options.session.eventBus,
 			onProgress: progress => emitProgressStatus(options.emitStatus, progress),
 			authStorage: options.session.authStorage,
 			modelRegistry: options.session.modelRegistry,
 			settings: options.session.settings,
+			// Eval `agent()` subagents are never wall-clock capped: the parent
+			// cell's idle watchdog is suspended for the whole bridge call
+			// (withBridgeTimeoutPause), so a long-running phase/recovery workflow
+			// must not be killed by `task.maxRuntimeMs`. Force the limit off
+			// regardless of the inherited session setting.
+			maxRuntimeMs: 0,
 			mcpManager,
 			contextFiles,
 			skills: availableSkills,
@@ -278,10 +296,8 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 		}),
 	);
 
-	if (result.exitCode !== 0 || result.error) {
-		const failureMessage =
-			result.error ?? result.stderr ?? result.abortReason ?? `agent() subagent '${agentName}' failed.`;
-		throw new ToolError(failureMessage);
+	if (result.exitCode !== 0 || result.error || result.aborted) {
+		throw new ToolError(buildSubagentFailureMessage(agentName, result));
 	}
 
 	options.session.recordEvalSubagentUsage?.(result.usage?.output ?? 0);

package/src/eval/backend.ts

@@ -1,3 +1,4 @@
+import { buildEvalUrlRoots, type LocalProtocolOptions } from "../internal-urls";
 import type { ToolSession } from "../tools";
 import type { EvalDisplayOutput, EvalLanguage, EvalStatusEvent } from "./types";
 
@@ -19,8 +20,6 @@ export interface ExecutorBackendExecOptions {
 	 */
 	idleTimeoutMs: number;
 	reset: boolean;
-	artifactPath: string | undefined;
-	artifactId: string | undefined;
 	onChunk: (chunk: string) => void;
 	/**
 	 * Live status events (read/write/agent/…) delivered as they are emitted,
@@ -56,3 +55,17 @@ export interface ExecutorBackend {
 	/** Execute one cell. Caller invokes once per cell and aggregates results. */
 	execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
 }
+
+/**
+ * Resolve the on-disk roots that the eval helpers substitute for internal-URL
+ * schemes (currently `local://`). Prefers the session's own
+ * {@link LocalProtocolOptions} — the exact mapping `read local://…` uses — so an
+ * eval `write("local://x")` and a later `read local://x` agree on the location.
+ */
+export function resolveEvalUrlRoots(session: ToolSession): Record<string, string> {
+	const options: LocalProtocolOptions = session.localProtocolOptions ?? {
+		getArtifactsDir: () => session.getArtifactsDir?.() ?? null,
+		getSessionId: () => session.getSessionId?.() ?? null,
+	};
+	return buildEvalUrlRoots(options);
+}

package/src/eval/bridge-timeout.ts

@@ -2,7 +2,7 @@
  * Timeout suspension for in-flight host-side eval bridge calls.
  *
  * The eval watchdog caps a cell's `timeout` as a budget on the cell runtime's
- * own work. Host-side `agent()` / `parallel()` / `llm()` bridge calls hand
+ * own work. Host-side `agent()` / `parallel()` / `completion()` bridge calls hand
  * control to the outer TypeScript process, where the Python kernel or JS VM is
  * only waiting for a result. While that delegated work is in flight, the cell
  * timeout must be ignored completely; once the bridge returns and the runtime is