@oh-my-pi/pi-coding-agent 17.2.12 → 17.2.14

package/src/tools/todo.ts

@@ -236,6 +236,13 @@ export function todoMatchesAnyDescription(content: string, descriptions: readonl
 	return false;
 }
 
+/** Whether a todo is settled: completed or deliberately abandoned. Shared so
+ *  the collapsed viewport, the HUD progress counters, and the HUD's closed-todo
+ *  auto-clear can never disagree about what "done" hides. */
+export function isClosedTodo<T extends { status: TodoStatus }>(task: T): boolean {
+	return task.status === "completed" || task.status === "abandoned";
+}
+
 /**
  * A todo the collapsed viewport treats as current work: the literal
  * `in_progress` task or a pending task a live subagent is executing. Both
@@ -254,36 +261,33 @@ export interface CollapsedTodoSelection<T> {
 }
 
 /**
- * Walking-viewport selection for a phase's collapsed todo preview (#5873).
+ * Closed rows kept directly above the open window so finishing a task is
+ * visible as it happens. Without this the collapsed viewport only ever renders
+ * unchecked boxes while a phase has open work: every completion silently
+ * removes a row, so a plan mid-flight looks untouched, and the card's
+ * completion strike animation (`completedTasks` → {@link TODO_STRIKE_TOTAL_FRAMES})
+ * animated a row that was never rendered.
+ */
+const COLLAPSED_CLOSED_CONTEXT = 1;
+
+/**
+ * Rows to show for a display base already reduced to the relevant tasks.
  *
- * Policy, applied to `tasks` in todo order:
- * 1. While the phase has open work, completed/abandoned tasks are omitted. A
- *    phase with no open tasks left falls back to its closed tasks so the sticky
- *    HUD's closed-todo persistence still has something to render.
- * 2. Every active task (in-progress, or pending matched to a live subagent) is
+ * 1. Every active task (in-progress, or pending matched to a live subagent) is
  *    placed at the head in stable todo order — never dropped for lying outside
  *    an ordinary window.
- * 3. Remaining rows up to `cap` are filled with the pending tasks that follow
+ * 2. Remaining rows up to `cap` are filled with the pending tasks that follow
  *    the first active one, in todo order (falling back to leading pending tasks
  *    when no active task exists), so a freshly-promoted task leads the preview.
- * 4. When active tasks alone exceed `cap`, only the first `cap` active tasks are
+ * 3. When active tasks alone exceed `cap`, only the first `cap` active tasks are
  *    shown and the summary counts the hidden *active* todos, never replacing
  *    them with unrelated pending rows.
- *
- * The summary otherwise counts the remaining tasks in the display base. Returns
- * the whole base with an empty summary when it already fits.
  */
-export function selectCollapsedTodos<T extends { status: TodoStatus }>(
-	tasks: T[],
+function selectWithinCap<T extends { status: TodoStatus }>(
+	base: T[],
 	isMatched: (task: T) => boolean,
 	cap: number,
 ): CollapsedTodoSelection<T> {
-	const open = tasks.filter(
-		task => task.status === "pending" || task.status === "in_progress" || task.status === "blocked",
-	);
-	// No open work: fall back to the closed tasks so a settled phase still
-	// renders (HUD closed-todo persistence). Closed tasks are never active.
-	const base = open.length > 0 ? open : tasks;
 	if (base.length <= cap) return { items: base, summary: "" };
 
 	const active = base.filter(task => isActiveTodo(task, isMatched));
@@ -312,6 +316,33 @@ export function selectCollapsedTodos<T extends { status: TodoStatus }>(
 	return { items, summary: hidden > 0 ? formatMoreItems(hidden, "todo") : "" };
 }
 
+/**
+ * Walking-viewport selection for a phase's collapsed todo preview (#5873).
+ *
+ * Applied to `tasks` in todo order: the open tasks run through
+ * {@link selectWithinCap}, led by the last {@link COLLAPSED_CLOSED_CONTEXT}
+ * closed tasks in todo order so a checked row remains visible even when callers
+ * complete work out of sequence. The lead is additive — it never costs an open
+ * row — and a phase with no open work left falls back to its closed tasks so the
+ * sticky HUD's closed-todo persistence still has something to render.
+ *
+ * `summary` counts the open tasks that did not fit; the closed lead is context,
+ * not part of the budget.
+ */
+export function selectCollapsedTodos<T extends { status: TodoStatus }>(
+	tasks: T[],
+	isMatched: (task: T) => boolean,
+	cap: number,
+): CollapsedTodoSelection<T> {
+	const open = tasks.filter(task => !isClosedTodo(task));
+	// Closed tasks are never active, so a settled phase selects over itself.
+	if (open.length === 0) return selectWithinCap(tasks, isMatched, cap);
+	// `done` accepts any named task, so closed tasks are not necessarily a prefix.
+	const lead = tasks.filter(isClosedTodo).slice(-COLLAPSED_CLOSED_CONTEXT);
+	const selected = selectWithinCap(open, isMatched, cap);
+	return { items: [...lead, ...selected.items], summary: selected.summary };
+}
+
 function resolveTaskOrError(
 	phases: TodoPhase[],
 	content: string | undefined,
@@ -1055,12 +1086,20 @@ function computeTouchedPhases(
 	return touched.size > 0 ? touched : null;
 }
 
+/**
+ * Dim `closed/total` suffix for a phase header. Counts closed tasks, not just
+ * completed ones: the collapsed viewport hides both, so an abandoned task has to
+ * move the counter or its phase reads as permanently stuck.
+ */
+function formatPhaseProgress(phase: TodoPhase, uiTheme: Theme): string {
+	const done = phase.tasks.filter(isClosedTodo).length;
+	return uiTheme.fg("dim", `  ${done}/${phase.tasks.length}`);
+}
+
 /** One-line summary for a collapsed (untouched) phase: dim header + progress. */
 function formatPhaseSummary(phase: TodoPhase, oneBasedIndex: number, uiTheme: Theme): string {
-	const total = phase.tasks.length;
-	const done = phase.tasks.filter(task => task.status === "completed").length;
 	const name = uiTheme.fg("dim", chalk.bold(formatPhaseDisplayName(phase.name, oneBasedIndex)));
-	return `${name}${uiTheme.fg("dim", `  ${done}/${total}`)}`;
+	return `${name}${formatPhaseProgress(phase, uiTheme)}`;
 }
 
 /**
@@ -1178,12 +1217,17 @@ export const todoToolRenderer = {
 					continue;
 				}
 				if (multiPhase) {
-					bodyLines.push(uiTheme.fg("accent", chalk.bold(formatPhaseDisplayName(phase.name, p + 1))));
+					// Progress belongs on the expanded header too: the collapsed
+					// viewport below hides closed rows, so without it the phase the
+					// agent is actually working in is the one phase with no visible
+					// completion signal at all.
+					const name = uiTheme.fg("accent", chalk.bold(formatPhaseDisplayName(phase.name, p + 1)));
+					bodyLines.push(`${name}${formatPhaseProgress(phase, uiTheme)}`);
 				}
 				const completionKeys = completionKeysByPhase.get(phase.name) ?? EMPTY_COMPLETION_KEYS;
-				// Collapsed: walking viewport — completed/abandoned omitted, active
-				// work (in-progress / subagent-matched) pulled to the head, then
-				// following pending tasks (#5873). Expanded: every task in order.
+				// Collapsed: walking viewport — the last closed task leads, then
+				// active work (in-progress / subagent-matched), then following
+				// pending tasks (#5873). Expanded: every task in order.
 				const treeLines = expanded
 					? renderTreeList(
 							{

package/src/tools/tts.ts

@@ -7,9 +7,10 @@ import { type } from "@oh-my-pi/omptype";
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type ApiKey, withAuth } from "@oh-my-pi/pi-ai";
 import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
+import { USER_AGENT } from "@oh-my-pi/pi-utils";
 import { settings } from "../config/settings";
 import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
-import { ohMyPiXAIUserAgent, resolveXAIHttpCredentials } from "../lib/xai-http";
+import { resolveXAIHttpCredentials } from "../lib/xai-http";
 import { DEFAULT_TTS_LOCAL_MODEL_KEY, DEFAULT_TTS_VOICE, isTtsLocalModelKey, KOKORO_VOICES } from "../tts/models";
 import { ttsClient } from "../tts/tts-client";
 import { encodeWav } from "../tts/wav";
@@ -150,7 +151,7 @@ async function synthesizeXai(
 					headers: {
 						Authorization: `Bearer ${key}`,
 						"Content-Type": "application/json",
-						"User-Agent": ohMyPiXAIUserAgent(),
+						"User-Agent": USER_AGENT,
 					},
 					body: JSON.stringify(payload),
 					signal: combinedSignal,

package/src/tools/write.ts

@@ -9,7 +9,7 @@ import type {
 	AgentToolContext,
 	AgentToolResult,
 	AgentToolUpdateCallback,
-	ToolTier,
+	ToolApprovalDecision,
 } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, isRecord, prompt, untilAborted } from "@oh-my-pi/pi-utils";
@@ -500,7 +500,7 @@ function parseSqliteWriteTarget(subPath: string, queryString: string): { table:
  */
 export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails> {
 	readonly name = "write";
-	readonly approval = (args: unknown): ToolTier => {
+	readonly approval = (args: unknown): ToolApprovalDecision => {
 		const rawPath = (args as Partial<WriteParams>).path;
 		if (typeof rawPath !== "string") return "write";
 		// Unwrap a hashline `[path#TAG]` wrapper first (parity with execute) so a
@@ -532,7 +532,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			}
 			if (!isRecord(parsed)) return "exec";
 			try {
-				return resolveToolTier(inst, parsed);
+				// The tier is the mounted tool's own (argument-dependent) approval; the
+				// policyKey makes the outer gate consult `tools.approval.<device>` for
+				// this dispatch before falling back to `tools.approval.write`, so users
+				// can scope allow/deny/prompt to a single device (issue #7923).
+				return { tier: resolveToolTier(inst, parsed), policyKey: xdevTarget.name! };
 			} catch {
 				return "exec";
 			}

package/src/utils/local-date.ts

@@ -5,3 +5,16 @@ export function formatLocalCalendarDate(date: Date = new Date()): string {
 	const day = String(date.getDate()).padStart(2, "0");
 	return `${year}-${month}-${day}`;
 }
+
+/** Format a local date and minute with a compact numeric UTC offset. */
+export function formatLocalDateTimeWithOffset(date: Date): string {
+	const offsetMinutes = date.getTimezoneOffset();
+	const offsetSign = offsetMinutes <= 0 ? "+" : "-";
+	const absoluteOffset = Math.abs(offsetMinutes);
+	const offsetHours = Math.floor(absoluteOffset / 60);
+	const offsetRemainderMinutes = absoluteOffset % 60;
+	const pad2 = (value: number): string => String(value).padStart(2, "0");
+	return `${formatLocalCalendarDate(date)} ${pad2(date.getHours())}:${pad2(date.getMinutes())} ${offsetSign}${pad2(
+		offsetHours,
+	)}:${pad2(offsetRemainderMinutes)}`;
+}

package/src/utils/tools-manager.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { $which, APP_NAME, getToolsDir, logger, ptree, TempDir } from "@oh-my-pi/pi-utils";
+import { $which, getToolsDir, logger, ptree, TempDir, USER_AGENT } from "@oh-my-pi/pi-utils";
 import { extractArchive } from "./zip";
 
 const TOOLS_DIR = getToolsDir();
@@ -174,7 +174,7 @@ async function getLatestVersion(repo: string, signal?: AbortSignal): Promise<str
 	let response: Response;
 	try {
 		response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
-			headers: { "User-Agent": `${APP_NAME}-coding-agent` },
+			headers: { "User-Agent": USER_AGENT },
 			signal: ptree.combineSignals(signal, TOOL_METADATA_TIMEOUT_MS),
 		});
 	} catch (err) {

package/src/vibe/runtime.ts

@@ -18,7 +18,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { logger, prompt, Snowflake } from "@oh-my-pi/pi-utils";
 import type { AsyncJob, AsyncJobManager } from "../async/job-manager";
-import { resolveAgentModelPatterns } from "../config/model-resolver";
+import { resolveAgentModelSelection } from "../config/model-resolver";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { registerArtifactsDir } from "../internal-urls/registry-helpers";
 import { MCPManager } from "../mcp/manager";
@@ -43,7 +43,7 @@ export type VibeCli = "fast" | "good";
  * CLI flavor → bundled agent type. This IS the model-tier mapping: `sonic`
  * carries `model: "@smol"` (the configured fast/low-latency role) and `task`
  * carries `model: "@task"` (inherits the session's strong model).
- * Resolution goes through {@link resolveAgentModelPatterns} exactly like a
+ * Resolution goes through {@link resolveAgentModelSelection} exactly like a
  * `task` spawn, so `task.agentModelOverrides` and model-role settings apply.
  */
 export const VIBE_CLI_AGENT: Record<VibeCli, string> = {
@@ -144,6 +144,8 @@ interface VibeRestoreCandidate {
 interface ResolvedVibeWorker {
 	agent: AgentDefinition;
 	modelOverride?: string | string[];
+	/** Pre-expansion role alias behind {@link modelOverride}, when the worker agent named one. */
+	modelRole?: string;
 }
 
 interface VibeTurn {
@@ -165,6 +167,8 @@ interface VibeRecord {
 	childSessionFile?: string;
 	agent: AgentDefinition;
 	modelOverride?: string | string[];
+	/** Pre-expansion role alias behind {@link modelOverride}, when the worker agent named one. */
+	modelRole?: string;
 	state: VibeSessionState;
 	createdAt: number;
 	lastActivityAt: number;
@@ -490,16 +494,17 @@ export class VibeSessionRegistry {
 			throw new ToolError(`Bundled agent "${agentName}" for vibe cli "${cli}" is unavailable.`);
 		}
 		const agentModelOverrides = session.settings.get("task.agentModelOverrides");
-		return {
-			agent,
-			modelOverride: resolveAgentModelPatterns({
-				settingsOverride: agentModelOverrides[agentName],
-				agentModel: agent.model,
-				settings: session.settings,
-				activeModelPattern: session.getActiveModelString?.(),
-				fallbackModelPattern: session.getModelString?.(),
-			}),
-		};
+		// Same contract as the task spawn path: the expansion discards the role
+		// alias (`@task`, `@smol`), so patterns and role identity come from one
+		// call — the child's inherited retry-fallback chain is keyed off the role.
+		const { patterns, role } = resolveAgentModelSelection({
+			settingsOverride: agentModelOverrides[agentName],
+			agentModel: agent.model,
+			settings: session.settings,
+			activeModelPattern: session.getActiveModelString?.(),
+			fallbackModelPattern: session.getModelString?.(),
+		});
+		return { agent, modelOverride: patterns, modelRole: role };
 	}
 
 	async #appendLifecycleEvent(
@@ -890,7 +895,7 @@ export class VibeSessionRegistry {
 				existing.sessionFile === childSessionFile &&
 				(existing.status === "idle" || existing.status === "parked");
 			const blockedByCollision = Boolean(existing && !existingIsResumable);
-			const { agent, modelOverride } = this.#resolveWorker(session, spawn.cli);
+			const { agent, modelOverride, modelRole } = this.#resolveWorker(session, spawn.cli);
 			if (!existing) {
 				AgentRegistry.global().register({
 					id: spawn.id,
@@ -911,6 +916,7 @@ export class VibeSessionRegistry {
 				childSessionFile,
 				agent,
 				modelOverride,
+				modelRole,
 				state: "idle",
 				createdAt: spawn.createdAt,
 				lastActivityAt: candidate.lastActivityAt,
@@ -945,7 +951,7 @@ export class VibeSessionRegistry {
 			throw new ToolError("Vibe mode has exited; enter Vibe mode again before spawning a worker.");
 		}
 		const manager = this.#manager(session);
-		const { agent, modelOverride } = this.#resolveWorker(session, args.cli);
+		const { agent, modelOverride, modelRole } = this.#resolveWorker(session, args.cli);
 		if (!session.agentOutputManager) {
 			session.agentOutputManager = new AgentOutputManager(session.getArtifactsDir ?? (() => null));
 		}
@@ -969,6 +975,7 @@ export class VibeSessionRegistry {
 			childSessionFile,
 			agent,
 			modelOverride,
+			modelRole,
 			state: "starting",
 			createdAt,
 			lastActivityAt: createdAt,
@@ -1418,6 +1425,7 @@ export class VibeSessionRegistry {
 			taskDepth: session.taskDepth ?? 0,
 			detached: true,
 			modelOverride: record.modelOverride,
+			modelRole: record.modelRole,
 			parentActiveModelPattern: session.getActiveModelString?.(),
 			thinkingLevel: record.agent.thinkingLevel,
 			sessionFile,

package/src/web/kagi.ts

@@ -98,7 +98,7 @@ export class KagiApiError extends Error {
 }
 
 function extractKagiErrorMessage(payload: unknown): string | null {
-	if (!payload || typeof payload !== "object") return null;
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
 	const record = payload as Record<string, unknown>;
 
 	for (const value of [record.message, record.detail]) {
@@ -107,17 +107,20 @@ function extractKagiErrorMessage(payload: unknown): string | null {
 		}
 	}
 
-	if (typeof record.error === "string" && record.error.trim().length > 0) {
-		return record.error.trim();
-	}
-
-	if (Array.isArray(record.error)) {
-		for (const entry of record.error) {
+	for (const errors of [record.error, record.errors]) {
+		if (typeof errors === "string" && errors.trim().length > 0) {
+			return errors.trim();
+		}
+		if (!Array.isArray(errors)) continue;
+		for (const entry of errors) {
 			if (!entry || typeof entry !== "object") continue;
 			const e = entry as Record<string, unknown>;
-			for (const value of [e.message, e.msg]) {
-				if (typeof value === "string" && value.trim().length > 0) {
-					return value.trim();
+			for (const value of [e.message, e.msg, e.code]) {
+				if (
+					(typeof value === "string" && value.trim().length > 0) ||
+					(typeof value === "number" && Number.isFinite(value))
+				) {
+					return String(value).trim();
 				}
 			}
 		}
@@ -147,6 +150,34 @@ function parseKagiErrorResponse(statusCode: number, responseText: string): KagiA
 	}
 }
 
+function parseKagiSuccessResponse(statusCode: number, responseText: string): KagiSearchResponse {
+	let payload: unknown;
+	try {
+		payload = JSON.parse(responseText);
+	} catch {
+		throw new KagiApiError("Kagi API returned an invalid response: invalid JSON", statusCode);
+	}
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+		throw new KagiApiError("Kagi API returned an invalid response: expected an object envelope", statusCode);
+	}
+
+	const record = payload as Record<string, unknown>;
+	const errorMessage = extractKagiErrorMessage(payload);
+	if (errorMessage && (record.error !== undefined || record.errors !== undefined)) {
+		const errors = Array.isArray(record.error) ? record.error : Array.isArray(record.errors) ? record.errors : [];
+		const first = errors[0];
+		const code =
+			first && typeof first === "object" && typeof (first as Record<string, unknown>).code === "number"
+				? ((first as Record<string, unknown>).code as number)
+				: statusCode;
+		throw createKagiApiError(code, errorMessage);
+	}
+	if (record.data !== undefined && (!record.data || typeof record.data !== "object" || Array.isArray(record.data))) {
+		throw new KagiApiError("Kagi API returned an invalid response: expected data to be an object", statusCode);
+	}
+	return payload as KagiSearchResponse;
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -216,23 +247,40 @@ function buildRequestBody(query: string, options: KagiSearchOptions): KagiSearch
 	return req;
 }
 
-/** Push every item in a result bucket as a source, with an optional title tag. */
-function collectSources(sources: KagiSearchSource[], items: KagiSearchResultItem[] | undefined, tag?: string): void {
-	if (!items) return;
-	for (const item of items) {
+function firstNonEmptyString(...values: unknown[]): string | undefined {
+	for (const value of values) {
+		if (typeof value === "string" && value.trim().length > 0) return value.trim();
+	}
+	return undefined;
+}
+
+/** Push every valid item in a result bucket as a source, with an optional title tag. */
+function collectSources(sources: KagiSearchSource[], items: unknown, tag?: string): void {
+	if (!Array.isArray(items)) return;
+	for (const value of items) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+		const item = value as Record<string, unknown>;
+		const url = firstNonEmptyString(item.url, item.href, item.link);
+		if (!url) continue;
+		const title = firstNonEmptyString(item.title, item.name) ?? url;
 		sources.push({
-			title: tag ? `${tag} ${item.title}` : item.title,
-			url: item.url,
-			snippet: item.snippet,
-			publishedDate: item.time,
+			title: tag ? `${tag} ${title}` : title,
+			url,
+			snippet: firstNonEmptyString(item.snippet, item.description, item.summary),
+			publishedDate: firstNonEmptyString(item.time),
 		});
 	}
 }
 
 /** Pull a related/adjacent question from an item's props or fall back to title. */
-function questionOf(item: KagiSearchResultItem): string | undefined {
-	const q = item.props?.question ?? item.props?.query ?? item.title;
-	return typeof q === "string" && q.length > 0 ? q : undefined;
+function questionOf(value: unknown): string | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const item = value as Record<string, unknown>;
+	const props =
+		item.props && typeof item.props === "object" && !Array.isArray(item.props)
+			? (item.props as Record<string, unknown>)
+			: undefined;
+	return firstNonEmptyString(props?.question, props?.query, item.title);
 }
 
 export async function searchWithKagi(
@@ -269,11 +317,7 @@ export async function searchWithKagi(
 		},
 	);
 
-	const payload = (await response.json()) as KagiSearchResponse;
-	if (payload.error && payload.error.length > 0) {
-		const first = payload.error[0];
-		throw createKagiApiError(first.code ?? response.status, extractKagiErrorMessage(payload) ?? first.message);
-	}
+	const payload = parseKagiSuccessResponse(response.status, await response.text());
 
 	const data = payload.data;
 	const sources: KagiSearchSource[] = [];
@@ -284,17 +328,30 @@ export async function searchWithKagi(
 	collectSources(sources, data?.news, "[News]");
 	collectSources(sources, data?.infobox, "[Info]");
 
-	for (const item of data?.adjacent_question ?? []) {
-		const q = questionOf(item);
-		if (q) relatedQuestions.push(q);
+	const adjacentQuestions: unknown = data?.adjacent_question;
+	if (Array.isArray(adjacentQuestions)) {
+		for (const item of adjacentQuestions) {
+			const question = questionOf(item);
+			if (question) relatedQuestions.push(question);
+		}
 	}
-	for (const item of data?.related_search ?? []) {
-		const q = questionOf(item);
-		if (q) relatedQuestions.push(q);
+	const relatedSearches: unknown = data?.related_search;
+	if (Array.isArray(relatedSearches)) {
+		for (const item of relatedSearches) {
+			const question = questionOf(item);
+			if (question) relatedQuestions.push(question);
+		}
 	}
 
-	const directAnswer = data?.direct_answer?.[0];
-	const answer = directAnswer ? (directAnswer.snippet ?? directAnswer.title) : undefined;
+	const directAnswers: unknown = data?.direct_answer;
+	const directAnswer = Array.isArray(directAnswers) ? directAnswers[0] : undefined;
+	const answer =
+		directAnswer && typeof directAnswer === "object" && !Array.isArray(directAnswer)
+			? firstNonEmptyString(
+					(directAnswer as Record<string, unknown>).snippet,
+					(directAnswer as Record<string, unknown>).title,
+				)
+			: undefined;
 
 	return {
 		requestId: payload.meta?.trace ?? payload.meta?.id ?? "",

package/src/web/parallel.ts

@@ -146,6 +146,15 @@ export function parseParallelErrorResponse(statusCode: number, responseText: str
 	}
 }
 
+export async function parseParallelJsonResponse(response: Response, operation: "search" | "extract"): Promise<unknown> {
+	try {
+		return await response.json();
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		throw new ParallelApiError(`Parallel ${operation} returned invalid JSON: ${detail}`);
+	}
+}
+
 function getAuthHeaders(apiKey: string): {
 	Accept: string;
 	"Content-Type": string;
@@ -316,7 +325,7 @@ export async function searchWithParallel(
 		throw parseParallelErrorResponse(response.status, await response.text());
 	}
 
-	const payload: unknown = await response.json();
+	const payload = await parseParallelJsonResponse(response, "search");
 	return parseParallelSearchPayload(payload);
 }
 
@@ -349,6 +358,6 @@ export async function extractWithParallel(
 		throw parseParallelErrorResponse(response.status, await response.text());
 	}
 
-	const payload: unknown = await response.json();
+	const payload = await parseParallelJsonResponse(response, "extract");
 	return parseExtractPayload(payload);
 }

package/src/web/scrapers/crates-io.ts

@@ -1,4 +1,4 @@
-import { tryParseJson } from "@oh-my-pi/pi-utils";
+import { tryParseJson, USER_AGENT } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatNumber, loadPage, looksLikeHtml } from "./types";
 
@@ -26,7 +26,7 @@ export const handleCratesIo: SpecialHandler = async (
 		const result = await loadPage(apiUrl, {
 			timeout,
 			signal,
-			headers: { "User-Agent": "omp-web-fetch/1.0 (https://github.com/anthropics)" },
+			headers: { "User-Agent": USER_AGENT },
 		});
 
 		if (!result.ok) return null;

package/src/web/scrapers/discogs.ts

@@ -5,7 +5,7 @@
  * API docs: https://www.discogs.com/developers
  */
 
-import { tryParseJson } from "@oh-my-pi/pi-utils";
+import { tryParseJson, USER_AGENT } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 
@@ -277,7 +277,7 @@ export const handleDiscogs: SpecialHandler = async (
 			signal,
 			headers: {
 				Accept: "application/json",
-				"User-Agent": "CodingAgent/1.0 +https://github.com/can1357/oh-my-pi",
+				"User-Agent": USER_AGENT,
 			},
 		});
 

package/src/web/scrapers/docs-rs.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { gunzipSync } from "node:zlib";
-import { getDocsRsCacheDir, isEnoent, logger, ptree, tryParseJson } from "@oh-my-pi/pi-utils";
+import { getDocsRsCacheDir, isEnoent, logger, ptree, tryParseJson, USER_AGENT } from "@oh-my-pi/pi-utils";
 import { ToolAbortError } from "../../tools/tool-errors";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, MAX_BYTES } from "./types";
@@ -388,7 +388,7 @@ export const handleDocsRs: SpecialHandler = async (
 		const requestSignal = ptree.combineSignals(signal, timeout * 1000);
 		const response = await fetch(jsonUrl, {
 			signal: requestSignal,
-			headers: { "User-Agent": "omp-web-fetch/1.0", Accept: "application/gzip" },
+			headers: { "User-Agent": USER_AGENT, Accept: "application/gzip" },
 			redirect: "follow",
 		});
 		if (!response.ok) return null;

package/src/web/scrapers/github.ts

@@ -1,4 +1,4 @@
-import { $env, ptree } from "@oh-my-pi/pi-utils";
+import { $env, ptree, USER_AGENT } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatMediaDuration, loadPage } from "./types";
 
@@ -121,7 +121,7 @@ export async function fetchGitHubApi(
 
 		const headers: Record<string, string> = {
 			Accept: "application/vnd.github.v3+json",
-			"User-Agent": "omp-web-fetch/1.0",
+			"User-Agent": USER_AGENT,
 		};
 
 		// Use GITHUB_TOKEN if available

package/src/web/scrapers/musicbrainz.ts

@@ -2,7 +2,7 @@
  * MusicBrainz URL handler for artists, releases, and recordings
  */
 
-import { tryParseJson } from "@oh-my-pi/pi-utils";
+import { tryParseJson, USER_AGENT } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatMediaDuration, loadPage } from "./types";
 
@@ -64,7 +64,6 @@ interface MusicBrainzRelease {
 }
 
 const MUSICBRAINZ_HOSTS = new Set(["musicbrainz.org", "www.musicbrainz.org"]);
-const USER_AGENT = "omp-web-fetch/1.0 (https://github.com/anthropics)";
 const MAX_TRACKS = 50;
 
 function parseEntity(url: URL): { entity: MusicBrainzEntity; mbid: string } | null {

package/src/web/scrapers/pubmed.ts

@@ -1,12 +1,12 @@
 /**
  * PubMed handler for web-fetch
  */
-import { tryParseJson } from "@oh-my-pi/pi-utils";
+import { tryParseJson, USER_AGENT } from "@oh-my-pi/pi-utils";
 import { buildResult, loadPage, type RenderResult, type SpecialHandler } from "./types";
 
 const NCBI_HEADERS = {
 	Accept: "application/json, text/plain;q=0.9, */*;q=0.8",
-	"User-Agent": "CodingAgent/1.0 (web scraper)",
+	"User-Agent": USER_AGENT,
 };
 
 /**