@oh-my-pi/pi-coding-agent 14.4.4 → 14.5.1

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [14.5.1] - 2026-04-26
+
+### Removed
+
+- Removed `\t` escaped-tab indentation autocorrect from hashline and atom edit modes (and the `PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS` environment toggle); literal `\t` in edit content is now preserved verbatim
+- Removed the suspicious-`\uDDDD` warning preflight from hashline edits
+- Removed the hand-rolled JSON unescape fallback in the streaming edit-arg renderer; partial fragments that fail `JSON.parse` are now surfaced raw rather than partially decoded with a non-spec-compliant unescaper that mishandled lone surrogates
+
 ## [14.4.3] - 2026-04-26
 ### Added
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.4.4",
+	"version": "14.5.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,13 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.20.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.4.4",
-		"@oh-my-pi/pi-agent-core": "14.4.4",
-		"@oh-my-pi/pi-ai": "14.4.4",
-		"@oh-my-pi/pi-natives": "14.4.4",
-		"@oh-my-pi/pi-tui": "14.4.4",
-		"@oh-my-pi/pi-utils": "14.4.4",
+		"@oh-my-pi/omp-stats": "14.5.1",
+		"@oh-my-pi/pi-agent-core": "14.5.1",
+		"@oh-my-pi/pi-ai": "14.5.1",
+		"@oh-my-pi/pi-natives": "14.5.1",
+		"@oh-my-pi/pi-tui": "14.5.1",
+		"@oh-my-pi/pi-utils": "14.5.1",
+		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.20.0",
@@ -62,7 +63,7 @@
 		"linkedom": "^0.18.12",
 		"lru-cache": "11.3.5",
 		"markit-ai": "0.5.3",
-		"puppeteer": "^24.42.0",
+		"puppeteer-core": "^24.42.0",
 		"turndown": "7.2.4",
 		"turndown-plugin-gfm": "1.0.2",
 		"zod": "4.3.6"

package/src/edit/modes/atom.ts

@@ -355,6 +355,19 @@ function applySedToLine(
 	}
 	if (re?.test(currentLine)) {
 		re.lastIndex = 0;
+		const probe = re.exec(currentLine);
+		re.lastIndex = 0;
+		if (probe && probe[0].length === 0) {
+			// Zero-length matches (e.g. `()`, `(?=…)`, `^`, `$`) cause `String.replace`
+			// to insert the replacement at the match position rather than substitute,
+			// which is almost never what models intend. Reject with a pointer to the
+			// dedicated insertion verbs.
+			return {
+				result: currentLine,
+				matched: false,
+				error: `pattern ${JSON.stringify(spec.pattern)} matches an empty string; use \`pre\`/\`post\`/\`splice\` to insert or replace whole lines, or use a non-empty pattern`,
+			};
+		}
 		return { result: currentLine.replace(re, spec.replacement), matched: true };
 	}
 	// Fall back to literal substring match. Models frequently send sed patterns
@@ -544,31 +557,6 @@ function validateNoConflictingAnchorOps(edits: AtomEdit[]): void {
 // Apply
 // ═══════════════════════════════════════════════════════════════════════════
 
-function maybeAutocorrectEscapedTabIndentation(edits: AtomEdit[], warnings: string[]): void {
-	const enabled = Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS !== "0";
-	if (!enabled) return;
-	for (const edit of edits) {
-		if (edit.op !== "splice" && edit.op !== "pre" && edit.op !== "post") continue;
-		if (edit.lines.length === 0) continue;
-		const hasEscapedTabs = edit.lines.some(line => line.includes("\\t"));
-		if (!hasEscapedTabs) continue;
-		const hasRealTabs = edit.lines.some(line => line.includes("\t"));
-		if (hasRealTabs) continue;
-		let correctedCount = 0;
-		const corrected = edit.lines.map(line =>
-			line.replace(/^((?:\\t)+)/, escaped => {
-				correctedCount += escaped.length / 2;
-				return "\t".repeat(escaped.length / 2);
-			}),
-		);
-		if (correctedCount === 0) continue;
-		edit.lines = corrected;
-		warnings.push(
-			`Auto-corrected escaped tab indentation in edit: converted leading \\t sequence(s) to real tab characters`,
-		);
-	}
-}
-
 export interface AtomNoopEdit {
 	editIndex: number;
 	loc: string;
@@ -599,7 +587,6 @@ export function applyAtomEdits(
 		throw new HashlineMismatchError(mismatches, fileLines);
 	}
 	validateNoConflictingAnchorOps(edits);
-	maybeAutocorrectEscapedTabIndentation(edits, warnings);
 
 	const trackFirstChanged = (line: number) => {
 		if (firstChangedLine === undefined || line < firstChangedLine) {
@@ -674,7 +661,7 @@ export function applyAtomEdits(
 				case "sed": {
 					const { result, matched, error, literalFallback } = applySedToLine(currentLine, edit.spec);
 					if (error) {
-						throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} failed to compile: ${error}`);
+						throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} rejected: ${error}`);
 					}
 					if (!matched) {
 						throw new Error(
@@ -786,9 +773,7 @@ export function applyAtomEdits(
 		}
 		if (!anyMatched) {
 			if (lastCompileError !== undefined) {
-				throw new Error(
-					`Edit sed expression ${JSON.stringify(edit.expression)} failed to compile: ${lastCompileError}`,
-				);
+				throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} rejected: ${lastCompileError}`);
 			}
 			throw new Error(`Edit sed expression ${JSON.stringify(edit.expression)} did not match any line in the file.`);
 		}

package/src/edit/modes/hashline.ts

@@ -681,55 +681,6 @@ export function tryRebaseAnchor(
 	return found;
 }
 
-function isEscapedTabAutocorrectEnabled(): boolean {
-	switch (Bun.env.PI_HASHLINE_AUTOCORRECT_ESCAPED_TABS) {
-		case "0":
-			return false;
-		case "1":
-			return true;
-		default:
-			return true;
-	}
-}
-
-function maybeAutocorrectEscapedTabIndentation(edits: HashlineEdit[], warnings: string[]): void {
-	if (!isEscapedTabAutocorrectEnabled()) return;
-	for (const edit of edits) {
-		if (edit.lines.length === 0) continue;
-		const hasEscapedTabs = edit.lines.some(line => line.includes("\\t"));
-		if (!hasEscapedTabs) continue;
-		const hasRealTabs = edit.lines.some(line => line.includes("\t"));
-		if (hasRealTabs) continue;
-		let correctedCount = 0;
-		const corrected = edit.lines.map(line =>
-			line.replace(/^((?:\\t)+)/, escaped => {
-				correctedCount += escaped.length / 2;
-				return "\t".repeat(escaped.length / 2);
-			}),
-		);
-		if (correctedCount === 0) continue;
-		edit.lines = corrected;
-		warnings.push(
-			`Auto-corrected escaped tab indentation in edit: converted leading \\t sequence(s) to real tab characters`,
-		);
-	}
-}
-
-function maybeWarnSuspiciousUnicodeEscapePlaceholder(edits: HashlineEdit[], warnings: string[]): void {
-	for (const edit of edits) {
-		if (edit.lines.length === 0) continue;
-		if (!edit.lines.some(line => /\\uDDDD/i.test(line))) continue;
-		warnings.push(
-			`Detected literal \\uDDDD in edit content; no autocorrection applied. Verify whether this should be a real Unicode escape or plain text.`,
-		);
-	}
-}
-
-function runHashlinePreflightSanitizers(edits: HashlineEdit[], warnings: string[]): void {
-	maybeAutocorrectEscapedTabIndentation(edits, warnings);
-	maybeWarnSuspiciousUnicodeEscapePlaceholder(edits, warnings);
-}
-
 function ensureHashlineEditHasContent(edit: HashlineEdit): void {
 	if (edit.lines.length === 0) {
 		edit.lines = [""];
@@ -1026,7 +977,6 @@ export function applyHashlineEdits(
 	if (mismatches.length > 0) {
 		throw new HashlineMismatchError(mismatches, fileLines);
 	}
-	runHashlinePreflightSanitizers(edits, warnings);
 	for (const edit of edits) {
 		collectBoundaryDuplicationWarning(edit, originalFileLines, warnings);
 	}

package/src/edit/renderer.ts

@@ -1,6 +1,7 @@
 /**
  * Edit tool renderer and LSP batching helpers.
  */
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -157,32 +158,16 @@ function filePathFromEditEntry(p: string | undefined): string | undefined {
 }
 
 function decodePartialJsonStringFragment(fragment: string): string {
-	let text = fragment;
+	// Trim a trailing partial escape so JSON.parse sees a well-formed 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);
-	}
+	if (trailingBackslashes % 2 === 1) text = text.slice(0, -1);
 	try {
 		return JSON.parse(`"${text}"`) as string;
 	} catch {
-		return text
-			.replace(/\\u([0-9a-fA-F]{4})/g, (_, hex: string) => String.fromCharCode(Number.parseInt(hex, 16)))
-			.replace(/\\(["\\/bfnrt])/g, (_, ch: string) => {
-				switch (ch) {
-					case "b":
-						return "\b";
-					case "f":
-						return "\f";
-					case "n":
-						return "\n";
-					case "r":
-						return "\r";
-					case "t":
-						return "\t";
-					default:
-						return ch;
-				}
-			});
+		// Streaming fragment isn't a valid JSON string yet; surface it raw rather
+		// than ad-hoc unescaping that mishandles surrogates and partial escapes.
+		return text;
 	}
 }
 
@@ -243,11 +228,11 @@ function formatEditDescription(
 	};
 }
 
-function renderPlainTextPreview(text: string, uiTheme: Theme): string {
-	const previewLines = text.split("\n");
+function renderPlainTextPreview(text: string, uiTheme: Theme, filePath?: string): string {
+	const previewLines = sanitizeText(text).split("\n");
 	let preview = "\n\n";
 	for (const line of previewLines.slice(0, CALL_TEXT_PREVIEW_LINES)) {
-		preview += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), CALL_TEXT_PREVIEW_WIDTH))}\n`;
+		preview += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line, filePath), CALL_TEXT_PREVIEW_WIDTH))}\n`;
 	}
 	if (previewLines.length > CALL_TEXT_PREVIEW_LINES) {
 		preview += uiTheme.fg("dim", `… ${previewLines.length - CALL_TEXT_PREVIEW_LINES} more lines`);
@@ -284,7 +269,7 @@ function formatMultiFileStreamingDiff(previews: PerFileDiffPreview[], uiTheme: T
 		if (!preview.diff && !preview.error) continue;
 		const header = uiTheme.fg("dim", `\n\n\u2500\u2500 ${shortenPath(preview.path)} \u2500\u2500`);
 		if (preview.error) {
-			parts.push(`${header}\n${uiTheme.fg("error", replaceTabs(preview.error))}`);
+			parts.push(`${header}\n${uiTheme.fg("error", replaceTabs(preview.error, preview.path))}`);
 			continue;
 		}
 		if (preview.diff) {
@@ -311,10 +296,10 @@ function getCallPreview(
 		return formatStreamingDiff(args.diff, rawPath, uiTheme);
 	}
 	if (args.diff) {
-		return renderPlainTextPreview(args.diff, uiTheme);
+		return renderPlainTextPreview(args.diff, uiTheme, rawPath);
 	}
 	if (args.newText || args.patch) {
-		return renderPlainTextPreview(args.newText ?? args.patch ?? "", uiTheme);
+		return renderPlainTextPreview(args.newText ?? args.patch ?? "", uiTheme, rawPath);
 	}
 	return "";
 }
@@ -438,7 +423,7 @@ export const editToolRenderer = {
 		}
 		text += getCallPreview(editArgs, rawPath, uiTheme, renderContext);
 		if (applyPatchSummary?.error) {
-			text += `\n\n${uiTheme.fg("error", truncateToWidth(replaceTabs(applyPatchSummary.error), CALL_TEXT_PREVIEW_WIDTH))}`;
+			text += `\n\n${uiTheme.fg("error", truncateToWidth(replaceTabs(applyPatchSummary.error, rawPath), CALL_TEXT_PREVIEW_WIDTH))}`;
 		}
 
 		return new Text(text, 0, 0);
@@ -529,13 +514,13 @@ function renderSingleFileResult(
 
 			if (isError) {
 				if (errorText) {
-					text += `\n\n${uiTheme.fg("error", replaceTabs(errorText))}`;
+					text += `\n\n${uiTheme.fg("error", replaceTabs(errorText, rawPath))}`;
 				}
 			} else if (details?.diff) {
 				text += renderDiffSection(details.diff, rawPath, expanded, uiTheme, renderDiffFn);
 			} else if (editDiffPreview) {
 				if ("error" in editDiffPreview) {
-					text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error))}`;
+					text += `\n\n${uiTheme.fg("error", replaceTabs(editDiffPreview.error, rawPath))}`;
 				} else if (editDiffPreview.diff) {
 					text += renderDiffSection(editDiffPreview.diff, rawPath, expanded, uiTheme, renderDiffFn);
 				}

package/src/modes/components/diff.ts

@@ -1,3 +1,4 @@
+import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { getIndentation } from "@oh-my-pi/pi-utils";
 import * as Diff from "diff";
 import { theme } from "../../modes/theme/theme";
@@ -15,7 +16,7 @@ const DIM_OFF = "\x1b[22m";
  */
 function visualizeIndent(text: string, filePath?: string): string {
 	const match = text.match(/^([ \t]+)/);
-	if (!match) return replaceTabs(text);
+	if (!match) return replaceTabs(text, filePath);
 	const indent = match[1];
 	const rest = text.slice(indent.length);
 	const tabWidth = getIndentation(filePath);
@@ -30,7 +31,7 @@ function visualizeIndent(text: string, filePath?: string): string {
 			visible += `${DIM}·${DIM_OFF}`;
 		}
 	}
-	return `${visible}${replaceTabs(rest)}`;
+	return `${visible}${replaceTabs(rest, filePath)}`;
 }
 
 /**
@@ -106,7 +107,7 @@ export interface RenderDiffOptions {
  * - Added lines: green, with inverse on changed tokens
  */
 export function renderDiff(diffText: string, options: RenderDiffOptions = {}): string {
-	const lines = diffText.split("\n");
+	const lines = sanitizeText(diffText).split("\n");
 	const result: string[] = [];
 	const parsedLines = lines.map(parseDiffLine);
 	const lineNumberWidth = parsedLines.reduce((width, parsed) => {
@@ -138,7 +139,7 @@ export function renderDiff(diffText: string, options: RenderDiffOptions = {}): s
 
 		if (!parsed) {
 			prevLineNum = "";
-			result.push(theme.fg("toolDiffContext", line));
+			result.push(theme.fg("toolDiffContext", replaceTabs(line, options.filePath)));
 			i++;
 			continue;
 		}

package/src/modes/controllers/event-controller.ts

@@ -172,12 +172,18 @@ export class EventController {
 			const signature = `${textContent}\u0000${imageCount}`;
 
 			this.#resetReadGroup();
-			if (this.ctx.optimisticUserMessageSignature !== signature) {
+			const wasOptimistic = this.ctx.optimisticUserMessageSignature === signature;
+			if (!wasOptimistic) {
 				this.ctx.addMessageToChat(event.message);
 			}
 			this.ctx.optimisticUserMessageSignature = undefined;
 
-			if (!event.message.synthetic) {
+			// Clear the editor only when the submission did not originate from this
+			// session's optimistic flow (which already cleared the editor at submit
+			// time). Clearing here on the optimistic path would race with the user
+			// typing the next prompt while the previous large redraw lands and erase
+			// their in-progress draft (#783).
+			if (!event.message.synthetic && !wasOptimistic) {
 				this.ctx.editor.setText("");
 				this.ctx.updatePendingMessagesDisplay();
 			}

package/src/tools/browser.ts

@@ -15,7 +15,7 @@ import type {
 	Page,
 	default as Puppeteer,
 	SerializedAXNode,
-} from "puppeteer";
+} from "puppeteer-core";
 import browserDescription from "../prompts/tools/browser.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { resizeImage } from "../utils/image-resize";
@@ -53,7 +53,7 @@ async function loadPuppeteer(): Promise<typeof Puppeteer> {
 	await Bun.write(path.join(safeDir, "package.json"), "{}");
 	try {
 		process.chdir(safeDir);
-		puppeteerModule = (await import("puppeteer")).default;
+		puppeteerModule = (await import("puppeteer-core")).default;
 		return puppeteerModule;
 	} finally {
 		process.chdir(prev);
@@ -61,50 +61,172 @@ async function loadPuppeteer(): Promise<typeof Puppeteer> {
 }
 
 /**
- * On NixOS, Puppeteer's bundled Chromium is a dynamically-linked FHS binary and
- * cannot run as-is. Detect the platform and resolve a system-installed Chromium
- * so `puppeteer.launch()` can use it instead of the bundled one.
+ * Lazily download Chromium on first browser launch via @puppeteer/browsers.
+ * Skipped when a system Chromium (NixOS) or PUPPETEER_EXECUTABLE_PATH is set.
+ * The browser is cached under ~/.omp/puppeteer (getPuppeteerDir).
+ */
+let chromiumExecutablePromise: Promise<string | undefined> | undefined;
+async function ensureChromiumExecutable(): Promise<string | undefined> {
+	const sysChrome = resolveSystemChromium();
+	if (sysChrome) return sysChrome;
+	const envPath = process.env.PUPPETEER_EXECUTABLE_PATH;
+	if (envPath) return envPath;
+	if (chromiumExecutablePromise) return chromiumExecutablePromise;
+
+	chromiumExecutablePromise = (async () => {
+		const [browsers, revisions] = await Promise.all([
+			import("@puppeteer/browsers"),
+			import("puppeteer-core/internal/revisions.js"),
+		]);
+		const platform = browsers.detectBrowserPlatform();
+		if (!platform) {
+			logger.warn("Could not detect browser platform; relying on puppeteer default resolution");
+			return undefined;
+		}
+		const cacheDir = getPuppeteerDir();
+		const buildId = await browsers.resolveBuildId(
+			browsers.Browser.CHROME,
+			platform,
+			revisions.PUPPETEER_REVISIONS.chrome,
+		);
+		const executablePath = browsers.computeExecutablePath({
+			browser: browsers.Browser.CHROME,
+			buildId,
+			cacheDir,
+			platform,
+		});
+		if (fs.existsSync(executablePath)) return executablePath;
+
+		logger.warn("Downloading Chromium for puppeteer (first browser use)", {
+			buildId,
+			platform,
+			cacheDir,
+		});
+		let lastReportedPercent = -1;
+		await browsers.install({
+			browser: browsers.Browser.CHROME,
+			buildId,
+			cacheDir,
+			platform,
+			downloadProgressCallback: (downloaded, total) => {
+				if (total <= 0) return;
+				const pct = Math.floor((downloaded / total) * 100);
+				if (pct >= lastReportedPercent + 10 || downloaded === total) {
+					lastReportedPercent = pct;
+					logger.debug(
+						`Chromium download: ${pct}% (${Math.round(downloaded / 1_000_000)} / ${Math.round(total / 1_000_000)} MB)`,
+					);
+				}
+			},
+		});
+		return executablePath;
+	})().catch(err => {
+		chromiumExecutablePromise = undefined;
+		throw new ToolError(
+			`Failed to install Chromium for puppeteer: ${(err as Error).message}. ` +
+				"Set PUPPETEER_EXECUTABLE_PATH to use an existing Chrome/Chromium binary, or install one manually.",
+		);
+	});
+	return chromiumExecutablePromise;
+}
+
+/**
+ * Resolve a system-installed Chrome/Chromium so `puppeteer.launch()` can reuse
+ * it instead of forcing a Chromium download. Returns `undefined` when no binary
+ * is found, which lets the caller fall back to a managed download.
  *
- * Detection order:
- *   1. `chromium` on PATH
- *   2. `chromium-browser` on PATH
- *   3. ~/.nix-profile/bin/chromium  (user profile)
- *   4. /run/current-system/sw/bin/chromium  (system profile)
+ * Detection order (per platform):
+ *   - macOS:   Google Chrome → Chromium → Microsoft Edge (system + user Applications)
+ *   - Linux:   PATH lookups (google-chrome, chromium, etc.) → common /usr/bin paths,
+ *              with NixOS-specific profile paths added when /etc/NIXOS exists
+ *   - Windows: Program Files / LocalAppData install paths for Chrome and Edge
  *
- * Returns `undefined` on non-NixOS systems or when no binary is found, which
- * causes Puppeteer to fall back to its default resolution.
+ * Honored regardless of platform: PUPPETEER_EXECUTABLE_PATH callers should bypass
+ * this entirely (handled in ensureChromiumExecutable).
  */
 let _resolvedChromium: string | null | undefined; // undefined = unchecked; null = not found
-function resolveSystemChromium(): string | undefined {
-	if (_resolvedChromium !== undefined) return _resolvedChromium ?? undefined;
+function isExecutableFile(p: string): boolean {
 	try {
-		if (!fs.existsSync("/etc/NIXOS")) {
-			_resolvedChromium = null;
-			return undefined;
-		}
+		const st = fs.statSync(p);
+		return st.isFile();
 	} catch {
-		_resolvedChromium = null;
-		return undefined;
+		return false;
 	}
-	const candidates = [
-		$which("chromium"),
-		$which("chromium-browser"),
-		path.join(os.homedir(), ".nix-profile/bin/chromium"),
-		"/run/current-system/sw/bin/chromium",
-	];
-	for (const candidate of candidates) {
-		if (candidate) {
+}
+
+function systemChromiumCandidates(): string[] {
+	const home = os.homedir();
+	const candidates: string[] = [];
+	switch (process.platform) {
+		case "darwin": {
+			for (const root of ["/Applications", path.join(home, "Applications")]) {
+				candidates.push(
+					path.join(root, "Google Chrome.app/Contents/MacOS/Google Chrome"),
+					path.join(root, "Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta"),
+					path.join(root, "Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev"),
+					path.join(root, "Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"),
+					path.join(root, "Chromium.app/Contents/MacOS/Chromium"),
+					path.join(root, "Microsoft Edge.app/Contents/MacOS/Microsoft Edge"),
+				);
+			}
+			break;
+		}
+		case "linux": {
+			const names = ["google-chrome-stable", "google-chrome", "chromium", "chromium-browser", "chrome"];
+			for (const name of names) {
+				const found = $which(name);
+				if (found) candidates.push(found);
+			}
+			candidates.push(
+				"/usr/bin/google-chrome-stable",
+				"/usr/bin/google-chrome",
+				"/usr/bin/chromium",
+				"/usr/bin/chromium-browser",
+				"/snap/bin/chromium",
+				"/var/lib/flatpak/exports/bin/com.google.Chrome",
+				"/var/lib/flatpak/exports/bin/org.chromium.Chromium",
+			);
+			let onNixos = false;
 			try {
-				if (fs.existsSync(candidate)) {
-					_resolvedChromium = candidate;
-					logger.debug("NixOS: using system Chromium", { path: candidate });
-					return candidate;
-				}
+				onNixos = fs.existsSync("/etc/NIXOS");
 			} catch {}
+			if (onNixos) {
+				candidates.push(path.join(home, ".nix-profile/bin/chromium"), "/run/current-system/sw/bin/chromium");
+			}
+			break;
+		}
+		case "win32": {
+			const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
+			const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+			const localAppData = process.env.LOCALAPPDATA ?? path.join(home, "AppData\\Local");
+			candidates.push(
+				path.join(programFiles, "Google\\Chrome\\Application\\chrome.exe"),
+				path.join(programFilesX86, "Google\\Chrome\\Application\\chrome.exe"),
+				path.join(localAppData, "Google\\Chrome\\Application\\chrome.exe"),
+				path.join(programFiles, "Chromium\\Application\\chrome.exe"),
+				path.join(localAppData, "Chromium\\Application\\chrome.exe"),
+				path.join(programFiles, "Microsoft\\Edge\\Application\\msedge.exe"),
+				path.join(programFilesX86, "Microsoft\\Edge\\Application\\msedge.exe"),
+			);
+			break;
+		}
+	}
+	return candidates;
+}
+
+function resolveSystemChromium(): string | undefined {
+	if (_resolvedChromium !== undefined) return _resolvedChromium ?? undefined;
+	const seen = new Set<string>();
+	for (const candidate of systemChromiumCandidates()) {
+		if (!candidate || seen.has(candidate)) continue;
+		seen.add(candidate);
+		if (isExecutableFile(candidate)) {
+			_resolvedChromium = candidate;
+			logger.debug("Using system Chrome/Chromium", { path: candidate });
+			return candidate;
 		}
 	}
 	_resolvedChromium = null;
-	logger.debug("NixOS detected but no Chromium binary found; Puppeteer may fail to launch");
 	return undefined;
 }
 
@@ -674,7 +796,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		this.#browser = await puppeteer.launch({
 			headless: this.#currentHeadless,
 			defaultViewport: this.#currentHeadless ? initialViewport : null,
-			executablePath: resolveSystemChromium(),
+			executablePath: await ensureChromiumExecutable(),
 			args: launchArgs,
 			ignoreDefaultArgs: [...STEALTH_IGNORE_DEFAULT_ARGS],
 		});

package/src/web/search/providers/zai.ts

@@ -14,7 +14,7 @@ import { SearchProvider } from "./base";
 import { findCredential, isApiKeyAvailable } from "./utils";
 
 const ZAI_MCP_URL = "https://api.z.ai/api/mcp/web_search_prime/mcp";
-const ZAI_TOOL_NAME = "webSearchPrime";
+const ZAI_TOOL_NAME = "web_search_prime";
 const DEFAULT_NUM_RESULTS = 10;
 
 export interface ZaiSearchParams {