@oh-my-pi/pi-coding-agent 16.5.1 → 16.5.2

package/src/advisor/runtime.ts

@@ -532,10 +532,13 @@ export class AdvisorRuntime {
 					// as a failed turn so endpoint rejections trip the retry path.
 					const promptError = this.agent.state.error;
 					if (promptError) throw new Error(promptError);
-					const emptyResponseError = getAdvisorEmptyResponseError(
-						this.agent.state.messages.slice(messageSnapshot),
-					);
-					if (emptyResponseError) throw emptyResponseError;
+					// A content-less stop is a deliberate silent review — the documented
+					// verifier behavior ("prefer silence when the agent is on track") — and
+					// completes the turn. Sessions can legitimately have nothing to advise
+					// on for any number of consecutive turns, so silence is never warned
+					// about (#5216 did, spamming "Advisor unavailable" at quiet models).
+					const turnError = getAdvisorTurnError(this.agent.state.messages.slice(messageSnapshot));
+					if (turnError) throw turnError;
 					success = true;
 					this.#consecutiveFailures = 0;
 					this.#failureNotified = false;
@@ -594,36 +597,15 @@ export class AdvisorRuntime {
 	}
 }
 
-function getAdvisorEmptyResponseError(messages: readonly AgentMessage[]): Error | undefined {
-	let sawAssistant = false;
-	for (const message of messages) {
-		if (message.role !== "assistant") continue;
-		sawAssistant = true;
-		if (message.stopReason !== "stop") return undefined;
-		if (hasAdvisorResponseContent(message)) return undefined;
-	}
-	if (sawAssistant) return new Error("Advisor turn returned an empty stop response without advice");
-	if (messages.length > 0) return new Error("Advisor turn ended without an assistant response");
-	return undefined;
-}
-
-function hasAdvisorResponseContent(message: AssistantMessage): boolean {
-	return message.content.some(block => {
-		switch (block.type) {
-			case "text":
-				return block.text.trim().length > 0;
-			case "thinking":
-				return block.thinking.trim().length > 0;
-			case "redactedThinking":
-				return block.data.length > 0;
-			case "toolCall":
-				return block.name.trim().length > 0;
-			case "fallback":
-				return false;
-			default:
-				return false;
-		}
-	});
+/**
+ * The only malformed advisor turn shape: the prompt resolved but produced no
+ * assistant response at all. Everything an assistant message carries — advice,
+ * reasoning, or deliberate silence (empty `stop`) — is a completed review.
+ */
+function getAdvisorTurnError(messages: readonly AgentMessage[]): Error | undefined {
+	if (messages.length === 0) return undefined;
+	if (messages.some(message => message.role === "assistant")) return undefined;
+	return new Error("Advisor turn ended without an assistant response");
 }
 
 type TextualContent = string | readonly (TextContent | ImageContent)[];

package/src/autoresearch/dashboard.ts

@@ -95,9 +95,9 @@ export function createDashboardController(): DashboardController {
 								done(undefined);
 								return;
 							}
-							if (matchesKey(data, "up") || data === "k") {
+							if (matchesKey(data, "up") || matchesKey(data, "k")) {
 								scrollOffset = Math.max(0, scrollOffset - 1);
-							} else if (matchesKey(data, "down") || data === "j") {
+							} else if (matchesKey(data, "down") || matchesKey(data, "j")) {
 								scrollOffset = Math.min(maxScroll, scrollOffset + 1);
 							} else if (matchesKey(data, "pageUp")) {
 								scrollOffset = Math.max(0, scrollOffset - viewportRows);

package/src/cli/config-cli.ts

@@ -241,7 +241,7 @@ export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
 
 	switch (cmd.action) {
 		case "list":
-			handleList(cmd.flags);
+			await handleList(cmd.flags);
 			break;
 		case "get":
 			handleGet(cmd.key, cmd.flags);
@@ -261,7 +261,19 @@ export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
 	}
 }
 
-function handleList(flags: { json?: boolean }): void {
+async function writeStdout(text: string): Promise<void> {
+	const pending = Promise.withResolvers<void>();
+	process.stdout.write(text, error => {
+		if (error) {
+			pending.reject(error);
+			return;
+		}
+		pending.resolve();
+	});
+	await pending.promise;
+}
+
+async function handleList(flags: { json?: boolean }): Promise<void> {
 	const defs = ALL_SETTING_PATHS.map(path => findSettingDef(path)).filter((def): def is CliSettingDef => !!def);
 
 	if (flags.json) {
@@ -273,7 +285,7 @@ function handleList(flags: { json?: boolean }): void {
 				description: def.description,
 			};
 		}
-		console.log(JSON.stringify(result, null, 2));
+		await writeStdout(`${JSON.stringify(result, null, 2)}\n`);
 		return;
 	}
 

package/src/config/settings-schema.ts

@@ -3592,6 +3592,16 @@ export const SETTINGS_SCHEMA = {
 			description: "Enable the tts tool for on-device (Kokoro) or xAI Grok Voice speech-file synthesis",
 		},
 	},
+	"generate_image.enabled": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "tools",
+			group: "Available Tools",
+			label: "Generate Image",
+			description: "Enable the generate_image tool for text-to-image generation and editing",
+		},
+	},
 
 	"inspect_image.enabled": {
 		type: "boolean",

package/src/cursor.ts

@@ -93,6 +93,7 @@ async function executeTool(
 		result = buildToolErrorResult(message);
 		isError = true;
 	}
+	isError ||= result.isError === true;
 
 	const sanitizedFinalResult: AgentToolResult<unknown> = {
 		content: result.content.map(c => (c.type === "text" ? { ...c, text: sanitizeText(c.text) } : c)),
@@ -283,6 +284,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 			result = buildToolErrorResult(message);
 			isError = true;
 		}
+		isError ||= result.isError === true;
 
 		// onUpdate may not fire for every chunk — flush any remaining output
 		// from the final result that wasn't already streamed.

package/src/discovery/claude-plugins.ts

@@ -24,7 +24,7 @@ import {
 	scanSkillsFromDir,
 } from "./helpers";
 
-import { substitutePluginRoot } from "./substitute-plugin-root";
+import { resolvePluginStdioPaths, substitutePluginRoot } from "./substitute-plugin-root";
 
 const PROVIDER_ID = "claude-plugins";
 const DISPLAY_NAME = "Claude Code Marketplace";
@@ -441,14 +441,20 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 				continue;
 			}
 			const namespacedName = root.plugin ? `${root.plugin}:${serverName}` : serverName;
+			const substitutedCommand =
+				raw.command !== undefined ? substitutePluginRoot(raw.command, root.path) : undefined;
+			const substitutedCwd = raw.cwd !== undefined ? substitutePluginRoot(raw.cwd, root.path) : undefined;
+			// Root relative command/cwd at the plugin's config directory, not the
+			// session cwd (MCP stdio spawning resolves relative values there).
+			const rooted = resolvePluginStdioPaths({ command: substitutedCommand, cwd: substitutedCwd }, root.path);
 			const server: MCPServer = {
 				name: namespacedName,
 				...(raw.enabled !== undefined && { enabled: raw.enabled }),
 				...(raw.timeout !== undefined && { timeout: raw.timeout }),
-				...(raw.command !== undefined && { command: substitutePluginRoot(raw.command, root.path) }),
+				...(rooted.command !== undefined && { command: rooted.command }),
 				...(raw.args !== undefined && { args: substitutePluginRoot(raw.args, root.path) }),
 				...(raw.env !== undefined && { env: substitutePluginRoot(raw.env, root.path) }),
-				...(raw.cwd !== undefined && { cwd: substitutePluginRoot(raw.cwd, root.path) }),
+				...(rooted.cwd !== undefined && { cwd: rooted.cwd }),
 				...(raw.url !== undefined && { url: expandEnvVarsDeep(raw.url) }),
 				...(raw.headers !== undefined && { headers: expandEnvVarsDeep(raw.headers) }),
 				...(raw.auth !== undefined && { auth: raw.auth }),

package/src/discovery/omp-plugins.ts

@@ -30,6 +30,7 @@ import { type CustomTool, toolCapability } from "../capability/tool";
 import type { LoadContext, LoadResult } from "../capability/types";
 import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
 import { listOmpExtensionRoots, type OmpExtensionRoot } from "./omp-extension-roots";
+import { resolvePluginStdioPaths } from "./substitute-plugin-root";
 
 const PROVIDER_ID = "omp-plugins";
 const DISPLAY_NAME = "OMP Extension Packages";
@@ -301,14 +302,17 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 				warnings.push(`[omp-plugins] Skipping MCP server "${serverName}" in ${mcpPath}: missing command or url`);
 				continue;
 			}
+			// Root relative command/cwd at the plugin's config directory, not the
+			// session cwd (MCP stdio spawning resolves relative values there).
+			const rooted = resolvePluginStdioPaths({ command: cfg.command, cwd: cfg.cwd }, root.path);
 			items.push({
 				name: serverName,
 				...(cfg.enabled !== undefined && { enabled: cfg.enabled }),
 				...(cfg.timeout !== undefined && { timeout: cfg.timeout }),
-				...(cfg.command !== undefined && { command: cfg.command }),
+				...(rooted.command !== undefined && { command: rooted.command }),
 				...(cfg.args !== undefined && { args: cfg.args }),
 				...(cfg.env !== undefined && { env: cfg.env }),
-				...(cfg.cwd !== undefined && { cwd: cfg.cwd }),
+				...(rooted.cwd !== undefined && { cwd: rooted.cwd }),
 				...(cfg.url !== undefined && { url: cfg.url }),
 				...(cfg.headers !== undefined && { headers: cfg.headers }),
 				...(cfg.auth !== undefined && { auth: cfg.auth }),

package/src/discovery/substitute-plugin-root.ts

@@ -1,3 +1,5 @@
+import * as path from "node:path";
+
 /**
  * Recursively substitute ${CLAUDE_PLUGIN_ROOT} and ${OMP_PLUGIN_ROOT}
  * with the actual plugin root path in strings, arrays, and plain objects.
@@ -27,3 +29,33 @@ export function substitutePluginRoot<T>(value: T, rootPath: string): T {
 	}
 	return value;
 }
+
+/**
+ * Rebase relative filesystem values in a discovered plugin stdio config against
+ * the directory of the `.mcp.json` that declared them.
+ *
+ * External plugin configs (bundled ChatGPT/Codex plugins, Claude marketplace
+ * plugins) express `command`/`cwd` relative to their own config file, but MCP
+ * stdio spawning roots relative values at the session cwd — so a plugin shipping
+ * `command: "./bin/server"`, `cwd: "."` launches from the wrong directory and
+ * fails with ENOENT. This resolves those against `configDir` instead:
+ *
+ * - relative `cwd` → resolved against `configDir`;
+ * - path-like `command` (`./`, `../`, or the Windows `.\`/`..\` forms) →
+ *   resolved against `configDir`;
+ * - bare executables (`npx`, `uvx`, …) and absolute paths are left untouched.
+ */
+export function resolvePluginStdioPaths(
+	config: { command?: string; cwd?: string },
+	configDir: string,
+): { command?: string; cwd?: string } {
+	const resolved: { command?: string; cwd?: string } = {};
+	if (typeof config.cwd === "string") {
+		resolved.cwd = path.isAbsolute(config.cwd) ? config.cwd : path.resolve(configDir, config.cwd);
+	}
+	if (config.command !== undefined) {
+		const isPathLike = /^\.\.?[/\\]/.test(config.command);
+		resolved.command = isPathLike ? path.resolve(configDir, config.command) : config.command;
+	}
+	return resolved;
+}

package/src/eval/__tests__/prelude-agent.test.ts

@@ -105,3 +105,23 @@ describe("eval js agent() handle", () => {
 		expect("branchName" in node).toBe(false);
 	});
 });
+
+describe("eval js read() URI delegation", () => {
+	it("appends line selectors to delegated URI paths", async () => {
+		const calls: Array<{ name: string; args: unknown }> = [];
+		const sandbox = loadPrelude(async (name, args) => {
+			calls.push({ name, args });
+			return { text: "resource contents" };
+		});
+
+		const result = await vm.runInContext(`read("mcp://server/resource", { offset: 10, limit: 5 })`, sandbox);
+
+		expect(result).toBe("resource contents");
+		expect(calls).toEqual([
+			{
+				name: "read",
+				args: { path: "mcp://server/resource:10-14" },
+			},
+		]);
+	});
+});

package/src/eval/backend.ts

@@ -15,10 +15,10 @@ export interface ExecutorBackendExecOptions {
 	 * driven entirely by `signal`, which the eval tool arms as a watchdog that
 	 * pauses on bridge timeout-control status events and fires a `TimeoutError`
 	 * reason only while the Python/JS runtime owns control. Backends use this
-	 * value only for timeout-annotation text and as cold-start headroom; they MUST
-	 * NOT derive a competing wall-clock timer from it.
+	 * value only for timeout-annotation text and as cold-start headroom; undefined
+	 * disables the cell timeout. Backends MUST NOT derive a competing wall-clock timer from it.
 	 */
-	idleTimeoutMs: number;
+	idleTimeoutMs?: number;
 	reset: boolean;
 	onChunk: (chunk: string) => void;
 	/**

package/src/eval/py/__tests__/prelude.test.ts

@@ -1,6 +1,30 @@
 import { describe, expect, it } from "bun:test";
 import { PYTHON_PRELUDE } from "../prelude";
 
+const pythonPath = Bun.env.PYTHON ?? "python3";
+
+async function runPrelude(
+	code: string,
+	env: Record<string, string>,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const prelude = PYTHON_PRELUDE.replace(
+		"from __future__ import annotations",
+		"from __future__ import annotations\n__omp_display = lambda *args, **kwargs: None",
+	);
+	const script = `${prelude}\n${code}`;
+	const proc = Bun.spawn([pythonPath, "-c", script], {
+		stdout: "pipe",
+		stderr: "pipe",
+		env: { ...process.env, ...env },
+	});
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	return { stdout, stderr, exitCode };
+}
+
 describe("python prelude", () => {
 	it("exposes read(path, offset?, limit?) with positional optional args", () => {
 		// The eval docs advertise `read(path, offset?=1, limit?=None)`. A
@@ -17,6 +41,54 @@ describe("python prelude", () => {
 		expect(signature).toContain("limit");
 	});
 
+	it("appends line selectors to delegated URI paths", async () => {
+		const requests: unknown[] = [];
+		const server = Bun.serve({
+			hostname: "127.0.0.1",
+			port: 0,
+			fetch: async request => {
+				requests.push(await request.json());
+				return Response.json({
+					ok: true,
+					value: { text: "resource contents", details: { resolvedPath: "/tmp/resource.txt" } },
+				});
+			},
+		});
+
+		try {
+			const result = await runPrelude(
+				[`print(read("artifact://21", 3, 2))`, `print(read("mcp://server/resource", 10, 5))`].join("\n"),
+				{
+					PI_TOOL_BRIDGE_URL: server.url.toString(),
+					PI_TOOL_BRIDGE_TOKEN: "test-token",
+					PI_TOOL_BRIDGE_SESSION: "test-session",
+				},
+			);
+
+			expect(result).toEqual({
+				stdout: "resource contents\nresource contents\n",
+				stderr: "",
+				exitCode: 0,
+			});
+			expect(requests).toEqual([
+				{
+					session: "test-session",
+					run: null,
+					name: "read",
+					args: { path: "artifact://21:3-4" },
+				},
+				{
+					session: "test-session",
+					run: null,
+					name: "read",
+					args: { path: "mcp://server/resource:10-14" },
+				},
+			]);
+		} finally {
+			server.stop(true);
+		}
+	});
+
 	it("exposes isolation artifacts on the agent() handle node", () => {
 		// agent(..., handle=True) is the only escape hatch for
 		// recovering apply=False patch/branch/nested artifacts (the bare

package/src/eval/py/prelude.py

@@ -57,6 +57,27 @@ if "__omp_prelude_loaded__" not in globals():
 
     _OMP_INTERNAL_URL_RE = re.compile(r"^([a-z][a-z0-9+.-]*)://(.*)$", re.IGNORECASE)
 
+    def _should_delegate_read(path: str | Path) -> bool:
+        return (
+            isinstance(path, str)
+            and _OMP_INTERNAL_URL_RE.match(path) is not None
+            and not path.lower().startswith("local://")
+        )
+
+    def _read_line_selector(offset: int, limit: int | None) -> str | None:
+        if offset <= 1 and limit is None:
+            return None
+        start = max(1, offset)
+        if limit is None:
+            return f"{start}-"
+        return f"{start}-{start + limit - 1}"
+
+    def _read_tool_text(path: str) -> str:
+        result = _bridge_call("read", {"path": path})
+        if isinstance(result, dict) and "text" in result:
+            return result["text"]
+        return result
+
     def _resolve_omp_path(path: str | Path) -> Path:
         """Map a helper path to a real filesystem Path.
 
@@ -94,7 +115,13 @@ if "__omp_prelude_loaded__" not in globals():
         return Path(resolved)
 
     def read(path: str | Path, offset: int = 1, limit: int | None = None) -> str:
-        """Read file contents. offset/limit are 1-indexed line numbers."""
+        """Read file or read-tool URI contents. offset/limit are 1-indexed lines."""
+        if _should_delegate_read(path):
+            if limit is not None and limit <= 0:
+                return ""
+            selector = _read_line_selector(offset, limit)
+            tool_path = path if selector is None else f"{path}:{selector}"
+            return _read_tool_text(tool_path)
         p = _resolve_omp_path(path)
         data = p.read_text(encoding="utf-8")
         lines = data.splitlines(keepends=True)

package/src/exec/bash-executor.ts

@@ -4,7 +4,7 @@
  * Uses brush-core via native bindings for shell execution.
  */
 import { ExponentialYield } from "@oh-my-pi/pi-agent-core/utils/yield";
-import { executeShell, type MinimizerOptions, Shell, type ShellRunResult } from "@oh-my-pi/pi-natives";
+import { type MinimizerOptions, Shell, type ShellRunResult } from "@oh-my-pi/pi-natives";
 import { isExecutable, type ShellConfig } from "@oh-my-pi/pi-utils/procmgr";
 import { Settings, type ShellMinimizerSettings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
@@ -250,6 +250,11 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		};
 	}
 
+	const shellOptions = {
+		sessionEnv: shellEnv,
+		snapshotPath: snapshotPath ?? undefined,
+		minimizer,
+	};
 	const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey, minimizer);
 	const persistentSessionBroken = brokenShellSessions.has(sessionKey);
 	if (persistentSessionBroken) {
@@ -264,13 +269,10 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	const sessionBusy = shellSessionsInUse.has(sessionKey);
 	let shellSession = persistentSessionBroken || sessionBusy ? undefined : shellSessions.get(sessionKey);
 	if (!shellSession && !persistentSessionBroken && !sessionBusy) {
-		shellSession = new Shell({
-			sessionEnv: shellEnv,
-			snapshotPath: snapshotPath ?? undefined,
-			minimizer,
-		});
+		shellSession = new Shell(shellOptions);
 		shellSessions.set(sessionKey, shellSession);
 	}
+	const executionShell = shellSession ?? new Shell(shellOptions);
 	const ownsPersistentSession = shellSession !== undefined;
 	if (ownsPersistentSession) {
 		shellSessionsInUse.add(sessionKey);
@@ -278,13 +280,15 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	const userSignal = options?.signal;
 	const runAbortController = new AbortController();
 	let abortCleanupPromise: Promise<void> | undefined;
+	const abortShell = (): Promise<void> => {
+		abortCleanupPromise ??= executionShell.abort().catch(() => undefined);
+		return abortCleanupPromise;
+	};
 	const abortCurrentExecution = () => {
 		if (!runAbortController.signal.aborted) {
 			runAbortController.abort();
 		}
-		if (shellSession && !abortCleanupPromise) {
-			abortCleanupPromise = shellSession.abort().catch(() => undefined);
-		}
+		void abortShell();
 	};
 	const abortDeferred = Promise.withResolvers<"abort">();
 	const abortHandler = () => {
@@ -317,38 +321,20 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	let resetSession = false;
 
 	try {
-		const runPromise = shellSession
-			? shellSession.run(
-					{
-						command: finalCommand,
-						cwd: commandCwd,
-						env: commandEnv,
-						timeoutMs: nativeTimeoutMs,
-						signal: runAbortController.signal,
-					},
-					(err, chunk) => {
-						if (!err) {
-							enqueueChunk(chunk);
-						}
-					},
-				)
-			: executeShell(
-					{
-						command: finalCommand,
-						cwd: commandCwd,
-						env: commandEnv,
-						sessionEnv: shellEnv,
-						snapshotPath: snapshotPath ?? undefined,
-						minimizer,
-						timeoutMs: nativeTimeoutMs,
-						signal: runAbortController.signal,
-					},
-					(err, chunk) => {
-						if (!err) {
-							enqueueChunk(chunk);
-						}
-					},
-				);
+		const runPromise = executionShell.run(
+			{
+				command: finalCommand,
+				cwd: commandCwd,
+				env: commandEnv,
+				timeoutMs: nativeTimeoutMs,
+				signal: runAbortController.signal,
+			},
+			(err, chunk) => {
+				if (!err) {
+					enqueueChunk(chunk);
+				}
+			},
+		);
 
 		const ey = new ExponentialYield();
 		const winner = await ey.race<
@@ -361,11 +347,12 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 
 		if (winner.kind === "timeout" || winner.kind === "abort") {
 			acceptingChunks = false;
+			const cleanupPromise = abortShell();
 			if (shellSession) {
 				resetSession = true;
-				quarantineShellSession(sessionKey, runPromise, abortCleanupPromise);
+				quarantineShellSession(sessionKey, runPromise, cleanupPromise);
 			} else {
-				void runPromise.catch(() => undefined);
+				void Promise.allSettled([runPromise, cleanupPromise]);
 			}
 			return {
 				exitCode: undefined,

package/src/extensibility/extensions/wrapper.ts

@@ -1,7 +1,7 @@
 /**
  * Tool wrappers for extensions.
  */
-import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai";
 import type { Settings } from "../../config/settings";
 import type { Theme } from "../../modes/theme/theme";
@@ -110,7 +110,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>,
 		context?: AgentToolContext,
-	) {
+	): Promise<AgentToolResult<TDetails, TParameters>> {
 		// 1. Check approval policy (before extension handlers).
 		// CLI `--auto-approve` / `--yolo` sets approval mode to yolo.
 		// User `tools.approval.<tool>` policies are still applied in all modes.
@@ -237,23 +237,23 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 				const modifiedContent: (TextContent | ImageContent)[] = resultResult.content ?? result.content;
 				const modifiedDetails = (resultResult.details ?? result.details) as TDetails;
 
-				// Extension can override error status
-				if (resultResult.isError === true && !executionError) {
-					// Extension marks a successful result as error
-					const textBlocks = (modifiedContent ?? []).filter((c): c is TextContent => c.type === "text");
-					const errorText = textBlocks.map(t => t.text).join("\n") || "Tool result marked as error by extension";
-					throw new Error(errorText);
-				}
-				if (resultResult.isError === false && executionError) {
-					// Extension clears the error - return success
-					return { content: modifiedContent, details: modifiedDetails };
-				}
+				// Effective error state: an explicit handler override wins; otherwise the
+				// original execution outcome stands. This lets a handler rewrite a failed
+				// call's model-visible content/details while keeping it an error, flip a
+				// failure to success, or flag a success as an error.
+				const effectiveError = resultResult.isError ?? !!executionError;
 
-				// Error status unchanged, but content/details may be modified
-				if (executionError) {
-					throw executionError;
-				}
-				return { content: modifiedContent, details: modifiedDetails };
+				// Return the (possibly modified) result carrying the error flag rather than
+				// rethrowing the original exception. The agent loop honors
+				// `AgentToolResult.isError` and surfaces it as a tool error on the wire (see
+				// `coerceToolResult` in agent-loop), so replacement failure content reaches
+				// the model while the call remains an error — the original exception text is
+				// no longer forced through, which previously discarded the replacement.
+				return {
+					content: modifiedContent,
+					details: modifiedDetails,
+					...(effectiveError ? { isError: true } : {}),
+				};
 			}
 		}