@oh-my-pi/pi-coding-agent 15.1.2 → 15.1.4

package/src/session/agent-storage.ts

@@ -1,7 +1,12 @@
 import { Database, type Statement } from "bun:sqlite";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { type AuthCredential, AuthCredentialStore, type StoredAuthCredential } from "@oh-my-pi/pi-ai";
+import {
+	type AuthCredential,
+	type AuthCredentialStore,
+	SqliteAuthCredentialStore,
+	type StoredAuthCredential,
+} from "@oh-my-pi/pi-ai";
 import { getAgentDbPath, isRecord, logger } from "@oh-my-pi/pi-utils";
 import type { RawSettings as Settings } from "../config/settings";
 
@@ -57,7 +62,7 @@ export class AgentStorage {
 		this.#hardenPermissions(dbPath);
 
 		// Create AuthCredentialStore with our open database
-		this.#authStore = new AuthCredentialStore(this.#db);
+		this.#authStore = new SqliteAuthCredentialStore(this.#db);
 
 		this.#listSettingsStmt = this.#db.prepare("SELECT key, value FROM settings");
 		this.#upsertModelUsageStmt = this.#db.prepare(

package/src/session/auth-broker-config.ts

@@ -0,0 +1,102 @@
+/**
+ * Resolve auth-broker connection configuration for the local omp client.
+ *
+ * Precedence (highest first):
+ *   1. `OMP_AUTH_BROKER_URL` / `OMP_AUTH_BROKER_TOKEN` env vars.
+ *   2. `auth.broker.url` / `auth.broker.token` in `~/.omp/agent/config.yml`
+ *      (hidden from the settings UI; `!command` resolution supported).
+ *   3. Token file `~/.omp/auth-broker.token` (paired with URL from env or config).
+ *
+ * Returns null when no broker URL is configured — caller falls back to the
+ * local SQLite store.
+ *
+ * Reads config.yml directly (instead of going through `Settings.init`) because
+ * `discoverAuthStorage` runs before the settings singleton is initialized in
+ * `runRootCommand`, and we want hand-edited config entries to be honoured at
+ * boot without forcing a startup reorder.
+ */
+import * as path from "node:path";
+import { getAgentDir, getConfigRootDir, isEnoent, logger } from "@oh-my-pi/pi-utils";
+import { YAML } from "bun";
+import { resolveConfigValue } from "../config/resolve-config-value";
+
+export interface AuthBrokerClientConfig {
+	url: string;
+	token: string;
+}
+
+/** Path to the local bearer token file. Created on the broker host by `omp auth-broker token`. */
+export function getAuthBrokerTokenFilePath(): string {
+	return path.join(getConfigRootDir(), "auth-broker.token");
+}
+
+async function readTokenFile(): Promise<string | null> {
+	try {
+		const raw = await Bun.file(getAuthBrokerTokenFilePath()).text();
+		const trimmed = raw.trim();
+		return trimmed.length > 0 ? trimmed : null;
+	} catch (err) {
+		if (isEnoent(err)) return null;
+		logger.warn("auth-broker token file unreadable", { error: String(err) });
+		return null;
+	}
+}
+
+interface ConfigSnapshot {
+	url?: string;
+	token?: string;
+}
+
+async function readConfigYaml(): Promise<ConfigSnapshot> {
+	const configPath = path.join(getAgentDir(), "config.yml");
+	try {
+		const raw = await Bun.file(configPath).text();
+		const parsed = YAML.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		const record = parsed as Record<string, unknown>;
+		const url = typeof record["auth.broker.url"] === "string" ? (record["auth.broker.url"] as string) : undefined;
+		const token =
+			typeof record["auth.broker.token"] === "string" ? (record["auth.broker.token"] as string) : undefined;
+		return { url, token };
+	} catch (err) {
+		if (isEnoent(err)) return {};
+		logger.warn("auth-broker config.yml unreadable", { error: String(err) });
+		return {};
+	}
+}
+
+/**
+ * Read broker configuration. Returns null when the URL is missing
+ * (broker disabled — local store is used). Throws when URL is set but no
+ * token is available — the caller cannot fall back silently because the
+ * user explicitly asked to use the broker.
+ */
+export async function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null> {
+	const envUrl = process.env.OMP_AUTH_BROKER_URL;
+	const envToken = process.env.OMP_AUTH_BROKER_TOKEN;
+
+	let url = envUrl && envUrl.length > 0 ? envUrl : undefined;
+	let configToken: string | undefined;
+	if (!url || !envToken) {
+		const fromConfig = await readConfigYaml();
+		if (!url && fromConfig.url) {
+			const resolved = await resolveConfigValue(fromConfig.url);
+			if (resolved && resolved.length > 0) url = resolved;
+		}
+		if (fromConfig.token) {
+			const resolved = await resolveConfigValue(fromConfig.token);
+			if (resolved && resolved.length > 0) configToken = resolved;
+		}
+	}
+	if (!url) return null;
+
+	const token =
+		(envToken && envToken.length > 0 ? envToken : undefined) ?? configToken ?? (await readTokenFile()) ?? undefined;
+	if (!token) {
+		throw new Error(
+			`OMP_AUTH_BROKER_URL is set (${url}) but no bearer token is available. ` +
+				`Set OMP_AUTH_BROKER_TOKEN, the \`auth.broker.token\` config entry, or place one at ${getAuthBrokerTokenFilePath()}.`,
+		);
+	}
+	return { url, token };
+}

package/src/session/auth-storage.ts

@@ -14,4 +14,10 @@ export type {
 	SerializedAuthStorage,
 	StoredAuthCredential,
 } from "@oh-my-pi/pi-ai";
-export { AuthStorage } from "@oh-my-pi/pi-ai";
+export {
+	AuthBrokerClient,
+	AuthStorage,
+	REMOTE_REFRESH_SENTINEL,
+	RemoteAuthCredentialStore,
+	SqliteAuthCredentialStore,
+} from "@oh-my-pi/pi-ai";

package/src/session/client-bridge.ts

@@ -25,6 +25,7 @@ export interface ClientBridgePermissionToolCall {
 	toolName: string;
 	title: string;
 	kind?: string;
+	status?: "pending" | "in_progress" | "completed" | "failed";
 	rawInput?: unknown;
 	locations?: { path: string; line?: number }[];
 }
@@ -70,6 +71,8 @@ export interface ClientBridgeCreateTerminalParams {
 
 export interface ClientBridge {
 	readonly capabilities: ClientBridgeCapabilities;
+	/** ACP v1 clients cannot show server-initiated turns as busy after prompt response. */
+	readonly deferAgentInitiatedTurns?: boolean;
 	readTextFile?(params: { path: string; line?: number; limit?: number }): Promise<string>;
 	writeTextFile?(params: { path: string; content: string }): Promise<void>;
 	createTerminal?(params: ClientBridgeCreateTerminalParams): Promise<ClientBridgeTerminalHandle>;

package/src/session/streaming-output.ts

@@ -1,5 +1,5 @@
 import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { sanitizeText } from "@oh-my-pi/pi-natives";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { formatBytes } from "../tools/render-utils";
 import { sanitizeWithOptionalSixelPassthrough } from "../utils/sixel";
 

package/src/task/types.ts

@@ -57,18 +57,13 @@ export interface SubagentLifecyclePayload {
 	index: number;
 }
 
-const assignmentDescriptionForContextEnabled =
-	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure. Only include per-task deltas — shared background belongs in `context`.";
-const assignmentDescriptionForContextDisabled =
-	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure, and include any background that would otherwise live in `context` since shared context is disabled in this mode.";
+const assignmentDescription = "per-task instructions; self-contained";
 
-const createTaskItemSchema = (contextEnabled: boolean) =>
+const createTaskItemSchema = (_contextEnabled: boolean) =>
 	z.object({
-		id: z.string().max(48).describe("CamelCase identifier, max 48 chars"),
-		description: z.string().describe("Short one-liner for UI display only — not seen by the subagent"),
-		assignment: z
-			.string()
-			.describe(contextEnabled ? assignmentDescriptionForContextEnabled : assignmentDescriptionForContextDisabled),
+		id: z.string().max(48).describe("camelcase identifier"),
+		description: z.string().describe("ui label, not seen by subagent"),
+		assignment: z.string().describe(assignmentDescription),
 	});
 
 /** Single task item for parallel execution (default shape with context enabled). */
@@ -80,44 +75,24 @@ const createTaskSchema = (options: { isolationEnabled: boolean; simpleMode: Task
 	const itemSchema = createTaskItemSchema(contextEnabled);
 
 	let schema = z.object({
-		agent: z.string().describe("Agent type for all tasks in this batch"),
-		tasks: z
-			.array(itemSchema)
-			.describe(
-				contextEnabled
-					? "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment."
-					: "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and fully self-contained inside assignment because shared context is disabled.",
-			),
+		agent: z.string().describe("agent type"),
+		tasks: z.array(itemSchema).describe("tasks to execute in parallel"),
 	});
-
 	if (contextEnabled) {
 		schema = schema.extend({
-			context: z
-				.string()
-				.optional()
-				.describe(
-					"Shared background prepended to every task's assignment. Put goal, non-goals, constraints, conventions, reference paths, API contracts, and global acceptance commands here once — instead of duplicating across assignments.",
-				),
+			context: z.string().optional().describe("shared background prepended to each assignment"),
 		});
 	}
 
 	if (customSchemaEnabled) {
 		schema = schema.extend({
-			schema: z
-				.string()
-				.optional()
-				.describe(
-					"JSON-encoded JTD schema defining expected response structure. Output format belongs here — never in context or assignment.",
-				),
+			schema: z.string().optional().describe("jtd schema for expected response shape"),
 		});
 	}
 
 	if (options.isolationEnabled) {
 		schema = schema.extend({
-			isolated: z
-				.boolean()
-				.optional()
-				.describe("Run in isolated environment; returns patches. Use when tasks edit overlapping files."),
+			isolated: z.boolean().optional().describe("run in isolated env; returns patches"),
 		});
 	}
 

package/src/tools/bash-interactive.ts

@@ -1,5 +1,5 @@
 import type { AgentToolContext } from "@oh-my-pi/pi-agent-core";
-import { type PtyRunResult, PtySession, sanitizeText } from "@oh-my-pi/pi-natives";
+import { type PtyRunResult, PtySession } from "@oh-my-pi/pi-natives";
 import {
 	type Component,
 	extractPrintableText,
@@ -10,6 +10,7 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Terminal as XtermTerminalType } from "@xterm/headless";
 import xterm from "@xterm/headless";
 import { Settings } from "../config/settings";
@@ -297,6 +298,7 @@ export async function runInteractiveBashPty(
 	},
 ): Promise<BashInteractiveResult> {
 	const settings = await Settings.init();
+	const { shell: resolvedShell } = settings.getShellConfig();
 	const sink = new OutputSink({
 		artifactPath: options.artifactPath,
 		artifactId: options.artifactId,
@@ -363,6 +365,7 @@ export async function runInteractiveBashPty(
 						signal: options.signal,
 						cols,
 						rows,
+						shell: resolvedShell,
 					},
 					(err, chunk) => {
 						if (finished || err || !chunk) return;

package/src/tools/bash-pty-selection.ts

@@ -9,6 +9,6 @@ export interface BashPtyContext {
 /** Return whether a bash tool call should use the local interactive PTY overlay. */
 export function canUseInteractiveBashPty(pty: boolean, ctx: BashPtyContext | undefined): boolean {
 	if (!pty) return false;
-	if (process.platform === "win32") return false;
-	return $env.PI_NO_PTY !== "1" && ctx?.hasUI === true && ctx.ui !== undefined;
+	if ($env.PI_NO_PTY === "1") return false;
+	return ctx?.hasUI === true && ctx.ui !== undefined;
 }

package/src/tools/browser.ts

@@ -18,19 +18,16 @@ export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 const DEFAULT_TAB_NAME = "main";
 
 const appSchema = z.object({
-	path: z.string().describe("absolute path to a binary to spawn (single-instance reuse)").optional(),
-	cdp_url: z.string().describe("existing CDP endpoint to connect to (e.g. http://127.0.0.1:9222)").optional(),
-	args: z.array(z.string()).describe("extra CLI args when spawning").optional(),
-	target: z.string().describe("substring matched against url+title to pick a BrowserWindow").optional(),
+	path: z.string().describe("binary path to spawn").optional(),
+	cdp_url: z.string().describe("existing cdp endpoint").optional(),
+	args: z.array(z.string()).describe("extra cli args").optional(),
+	target: z.string().describe("substring to pick a window").optional(),
 });
 
 const browserSchema = z.object({
-	action: z.enum(["open", "close", "run"] as const).describe("tab/browser operation"),
-	name: z
-		.string()
-		.describe("tab id; default 'main'. Multiple tabs can coexist; reusable across run() calls and subagents.")
-		.optional(),
-	url: z.string().describe("open: navigate after acquiring tab").optional(),
+	action: z.enum(["open", "close", "run"] as const).describe("operation"),
+	name: z.string().describe("tab id (default 'main')").optional(),
+	url: z.string().describe("url to open").optional(),
 	app: appSchema.optional(),
 	viewport: z
 		.object({
@@ -41,21 +38,16 @@ const browserSchema = z.object({
 		.optional(),
 	wait_until: z
 		.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"] as const)
-		.describe("navigation wait condition for url")
+		.describe("navigation wait condition")
 		.optional(),
 	dialogs: z
 		.enum(["accept", "dismiss"] as const)
-		.describe("open: auto-handle alert/confirm/beforeunload dialogs (default: leave for caller to handle)")
-		.optional(),
-	code: z
-		.string()
-		.describe(
-			"run: JS body executed with `page`, `browser`, `tab`, `display`, `assert`, `wait` in scope. Treated as the body of an async function. Use `display(value)` to attach text/JSON/images; the function's return value is JSON-serialized as a final block.",
-		)
+		.describe("auto-handle dialogs")
 		.optional(),
+	code: z.string().describe("js body to run in tab").optional(),
 	timeout: z.number().default(30).describe("timeout in seconds").optional(),
-	all: z.boolean().describe("close: close every tab").optional(),
-	kill: z.boolean().describe("close: also kill spawned-app browsers (default: leave running)").optional(),
+	all: z.boolean().describe("close every tab").optional(),
+	kill: z.boolean().describe("also kill spawned-app browsers").optional(),
 });
 
 /** Input schema for the browser tool. */

package/src/tools/eval.ts

@@ -4,10 +4,8 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Markdown, Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
-import { jsBackend, parseEvalInput, pythonBackend, sniffEvalLanguage } from "../eval";
+import { jsBackend, pythonBackend } from "../eval";
 import type { ExecutorBackend } from "../eval/backend";
-import evalGrammar from "../eval/eval.lark" with { type: "text" };
-import { ABORT_WARNING, type ParsedEvalCell } from "../eval/parse";
 import type { EvalCellResult, EvalDisplayOutput, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { truncateToVisualLines } from "../modes/components/visual-truncate";
@@ -29,8 +27,27 @@ import { clampTimeout } from "./tool-timeouts";
 
 export const EVAL_DEFAULT_PREVIEW_LINES = 10;
 
+/**
+ * Per-cell input. Each cell runs in order; state persists within a language
+ * across cells and across tool calls.
+ */
+const evalCellSchema = z.object({
+	language: z.enum(["py", "js"]).describe('runtime: "py" for the IPython kernel, "js" for the persistent JS VM'),
+	code: z.string().describe("cell body, verbatim. Use top-level await freely."),
+	title: z.string().optional().describe('short label shown in transcript (e.g. "imports", "load config")'),
+	timeout: z.number().int().min(1).max(600).optional().describe("per-cell timeout in seconds (1-600, default 30)"),
+	reset: z
+		.boolean()
+		.optional()
+		.describe("wipe this cell's language kernel before running. Other languages are untouched."),
+});
+export type EvalCellInput = z.infer<typeof evalCellSchema>;
+
 export const evalSchema = z.object({
-	input: z.string().describe('eval input as a sequence of `*** Cell <lang>:"title"` cell headers followed by code'),
+	cells: z
+		.array(evalCellSchema)
+		.min(1)
+		.describe("cells executed in order. State persists within each language across cells and tool calls."),
 });
 export type EvalToolParams = z.infer<typeof evalSchema>;
 
@@ -134,7 +151,6 @@ export interface EvalToolOptions {
 
 interface ResolvedBackend {
 	backend: ExecutorBackend;
-	fallback: boolean;
 	notice?: string;
 }
 
@@ -166,51 +182,21 @@ function timeoutSecondsFromMs(timeoutMs: number): number {
 	return clampTimeout("eval", timeoutMs / 1000);
 }
 
-async function resolveBackend(
-	session: ToolSession,
-	requested: EvalLanguage | undefined,
-	code: string,
-): Promise<ResolvedBackend> {
+async function resolveBackend(session: ToolSession, language: EvalLanguage): Promise<ResolvedBackend> {
 	const allowPy = (session.settings.get("eval.py") as boolean | undefined) ?? true;
 	const allowJs = (session.settings.get("eval.js") as boolean | undefined) ?? true;
 
-	if (requested === "python") {
+	if (language === "python") {
 		if (!allowPy) throw new ToolError("Python backend is disabled (eval.py = false).");
 		if (!(await pythonBackend.isAvailable(session))) {
 			throw new ToolError(
 				'Python backend is unavailable in this session. Pass language: "js" or install the python kernel.',
 			);
 		}
-		return { backend: pythonBackend, fallback: false };
-	}
-	if (requested === "js") {
-		if (!allowJs) throw new ToolError("JavaScript backend is disabled (eval.js = false).");
-		return { backend: jsBackend, fallback: false };
-	}
-	// Auto-detect.
-	const sniffed = sniffEvalLanguage(code);
-	if (sniffed === "python" && allowPy && (await pythonBackend.isAvailable(session))) {
-		return { backend: pythonBackend, fallback: false };
-	}
-	if (sniffed === "js" && allowJs) {
-		return { backend: jsBackend, fallback: false };
+		return { backend: pythonBackend };
 	}
-
-	// Sniffer returned undefined or the preferred backend was disabled. Prefer
-	// python when its kernel is up, else fall back to js.
-	if (allowPy && (await pythonBackend.isAvailable(session))) {
-		const notice =
-			sniffed === "js" ? "JavaScript markers detected but eval.js is disabled; using Python." : undefined;
-		return { backend: pythonBackend, fallback: false, notice };
-	}
-	if (allowJs) {
-		const notice =
-			sniffed === "python"
-				? "Python markers detected but the python kernel is unavailable; using JavaScript."
-				: undefined;
-		return { backend: jsBackend, fallback: true, notice };
-	}
-	throw new ToolError("No eval backend is available; enable eval.py or eval.js.");
+	if (!allowJs) throw new ToolError("JavaScript backend is disabled (eval.js = false).");
+	return { backend: jsBackend };
 }
 
 export class EvalTool implements AgentTool<typeof evalSchema> {
@@ -227,20 +213,15 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 	readonly intent = (args: Partial<z.infer<typeof evalSchema>>): string | undefined => {
-		const input = args.input;
-		if (input) {
-			try {
-				const cells = parseEvalInput(input).cells;
-				return cells.map(cell => cell.title || `running ${cell.language}`).join("\n");
-			} catch {}
-		}
-		return "evaluating";
+		const cells = Array.isArray(args.cells) ? args.cells : [];
+		const first = cells.find(c => c && typeof c === "object");
+		if (!first) return "evaluating";
+		const title = typeof first.title === "string" ? first.title : undefined;
+		const language = typeof first.language === "string" ? first.language : "?";
+		const label = title || `running ${language}`;
+		return cells.length > 1 ? `${label} (+${cells.length - 1})` : label;
 	};
 
-	get customFormat(): { syntax: "lark"; definition: string } {
-		return { syntax: "lark", definition: evalGrammar };
-	}
-
 	readonly #proxyExecutor?: EvalProxyExecutor;
 
 	constructor(
@@ -266,19 +247,17 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 		}
 		const session = this.session;
 
-		const parsedInput = parseEvalInput(params.input);
-		let previousRuntimeLanguage: EvalLanguage | undefined;
 		const cells: ResolvedEvalCell[] = [];
-		for (const cell of parsedInput.cells) {
-			const requested = cell.languageOrigin === "header" ? cell.language : (previousRuntimeLanguage ?? undefined);
-			const resolved = await resolveBackend(session, requested, cell.code);
-			previousRuntimeLanguage = resolved.backend.id;
+		for (let i = 0; i < params.cells.length; i++) {
+			const cell = params.cells[i];
+			const language: EvalLanguage = cell.language === "py" ? "python" : "js";
+			const resolved = await resolveBackend(session, language);
 			cells.push({
-				index: cell.index,
+				index: i,
 				title: cell.title,
 				code: cell.code,
-				timeoutMs: cell.timeoutMs,
-				reset: cell.reset,
+				timeoutMs: (cell.timeout ?? 30) * 1000,
+				reset: cell.reset ?? false,
 				resolved,
 			});
 		}
@@ -462,11 +441,10 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 						pushUpdate();
 						const errorMsg = result.output || "Command aborted";
 						const combinedOutput = cellOutputs.join("\n\n");
-						const abortSuffix = parsedInput.aborted ? `\n\n${ABORT_WARNING}` : "";
 						const outputText =
-							(cells.length > 1
+							cells.length > 1
 								? `${combinedOutput}\n\nCell ${i + 1} aborted: ${errorMsg}`
-								: combinedOutput || errorMsg) + abortSuffix;
+								: combinedOutput || errorMsg;
 
 						const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 						const details: EvalToolDetails = {
@@ -489,13 +467,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 						cellResult.status = "error";
 						pushUpdate();
 						const combinedOutput = cellOutputs.join("\n\n");
-						const abortSuffix = parsedInput.aborted ? `\n\n${ABORT_WARNING}` : "";
 						const outputText =
-							(cells.length > 1
+							cells.length > 1
 								? `${combinedOutput}\n\nCell ${i + 1} failed (exit code ${result.exitCode}). Earlier cells succeeded—their state persists. Fix only cell ${i + 1}.`
 								: combinedOutput
 									? `${combinedOutput}\n\nCommand exited with code ${result.exitCode}`
-									: `Command exited with code ${result.exitCode}`) + abortSuffix;
+									: `Command exited with code ${result.exitCode}`;
 
 						const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 						const details: EvalToolDetails = {
@@ -519,13 +496,12 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 				}
 
 				const combinedOutput = cellOutputs.join("\n\n");
-				const abortSuffix = parsedInput.aborted ? `\n\n${ABORT_WARNING}` : "";
 				const hasImages = images.length > 0;
 				const outputText =
-					(combinedOutput ||
-						(hasImages
-							? `(displayed ${images.length} image${images.length === 1 ? "" : "s"}; no text output)`
-							: "(no output)")) + abortSuffix;
+					combinedOutput ||
+					(hasImages
+						? `(displayed ${images.length} image${images.length === 1 ? "" : "s"}; no text output)`
+						: "(no output)");
 				const summaryForMeta = await summarizeFinal(combinedOutput, finalizeOutput);
 
 				const details: EvalToolDetails = {
@@ -581,8 +557,14 @@ async function summarizeFinal(
 	};
 }
 
+interface EvalRenderCellArg {
+	language?: string;
+	code?: string;
+	title?: string;
+}
+
 interface EvalRenderArgs {
-	input?: string;
+	cells?: EvalRenderCellArg[];
 	__partialJson?: string;
 }
 
@@ -593,27 +575,30 @@ interface EvalRenderContext {
 	timeout?: number;
 }
 
-function decodePartialJsonStringFragment(fragment: string): string {
-	let text = fragment.replace(/\\u[0-9a-fA-F]{0,3}$/, "");
-	const trailingBackslashes = text.match(/\\+$/)?.[0].length ?? 0;
-	if (trailingBackslashes % 2 === 1) text = text.slice(0, -1);
-	try {
-		return JSON.parse(`"${text}"`) as string;
-	} catch {
-		return text;
-	}
+interface EvalRenderCell {
+	language: EvalLanguage;
+	code: string;
+	title?: string;
 }
 
-function extractPartialJsonString(partialJson: string | undefined, key: string): string | undefined {
-	if (!partialJson) return undefined;
-	const pattern = new RegExp(`"${key}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)`, "u");
-	const match = pattern.exec(partialJson);
-	if (!match) return undefined;
-	return decodePartialJsonStringFragment(match[1]);
+function normalizeRenderLanguage(value: string | undefined): EvalLanguage {
+	return value === "js" ? "js" : "python";
 }
 
-function getRenderInput(args: EvalRenderArgs | undefined): string | undefined {
-	return args?.input ?? extractPartialJsonString(args?.__partialJson, "input");
+function getRenderCells(args: EvalRenderArgs | undefined): EvalRenderCell[] {
+	const raw = args?.cells;
+	if (!Array.isArray(raw)) return [];
+	const out: EvalRenderCell[] = [];
+	for (const cell of raw) {
+		if (!cell || typeof cell !== "object") continue;
+		const code = typeof cell.code === "string" ? cell.code : "";
+		out.push({
+			language: normalizeRenderLanguage(typeof cell.language === "string" ? cell.language : undefined),
+			code,
+			title: typeof cell.title === "string" ? cell.title : undefined,
+		});
+	}
+	return out;
 }
 
 /** Format a status event as a single line for display. */
@@ -861,15 +846,7 @@ function formatCellOutputLines(
 
 export const evalToolRenderer = {
 	renderCall(args: EvalRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const input = getRenderInput(args);
-		let cells: ParsedEvalCell[] = [];
-		if (input) {
-			try {
-				cells = parseEvalInput(input).cells;
-			} catch {
-				cells = [];
-			}
-		}
+		const cells = getRenderCells(args);
 
 		if (cells.length === 0) {
 			const promptSym = uiTheme.fg("accent", ">>>");
@@ -881,7 +858,7 @@ export const evalToolRenderer = {
 
 		return {
 			render: (width: number): string[] => {
-				const key = `${input?.length ?? 0}`;
+				const key = cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|");
 				if (cached && cached.key === key && cached.width === width) {
 					return cached.result;
 				}