@oh-my-pi/pi-coding-agent 3.20.1 → 3.24.0

package/src/core/tools/task/worker.ts

@@ -0,0 +1,238 @@
+/**
+ * Worker thread for subagent execution.
+ *
+ * This worker runs in a separate thread via Bun's Worker API. It creates a minimal
+ * AgentSession and forwards events back to the parent thread.
+ *
+ * ## Event Flow
+ *
+ * 1. Parent sends { type: "start", payload } with task config
+ * 2. Worker creates AgentSession and subscribes to events
+ * 3. Worker forwards AgentEvent messages via postMessage
+ * 4. Worker sends { type: "done", exitCode, ... } on completion
+ * 5. Parent can send { type: "abort" } to request cancellation
+ */
+
+import type { Api, Model } from "@mariozechner/pi-ai";
+import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AgentSessionEvent } from "../../agent-session";
+import { parseModelPattern, parseModelString } from "../../model-resolver";
+import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
+import { SessionManager } from "../../session-manager";
+import type { SubagentWorkerRequest, SubagentWorkerResponse, SubagentWorkerStartPayload } from "./worker-protocol";
+
+type PostMessageFn = (message: SubagentWorkerResponse) => void;
+
+const postMessageSafe: PostMessageFn = (message) => {
+	(globalThis as typeof globalThis & { postMessage: PostMessageFn }).postMessage(message);
+};
+
+interface WorkerMessageEvent<T> {
+	data: T;
+}
+
+/** Agent event types to forward to parent (excludes session-only events like compaction) */
+const agentEventTypes = new Set<AgentEvent["type"]>([
+	"agent_start",
+	"agent_end",
+	"turn_start",
+	"turn_end",
+	"message_start",
+	"message_update",
+	"message_end",
+	"tool_execution_start",
+	"tool_execution_update",
+	"tool_execution_end",
+]);
+
+const isAgentEvent = (event: AgentSessionEvent): event is AgentEvent => {
+	return agentEventTypes.has(event.type as AgentEvent["type"]);
+};
+
+let running = false;
+let abortRequested = false;
+let activeSession: { abort: () => Promise<void>; dispose: () => Promise<void> } | null = null;
+
+/**
+ * Resolve model string to Model object with optional thinking level.
+ * Supports both exact "provider/id" format and fuzzy matching ("sonnet", "opus").
+ */
+function resolveModelOverride(
+	override: string | undefined,
+	modelRegistry: { getAvailable: () => Model<Api>[]; find: (provider: string, id: string) => Model<Api> | undefined },
+): { model?: Model<Api>; thinkingLevel?: ThinkingLevel } {
+	if (!override) return {};
+
+	// Try exact "provider/id" format first
+	const parsed = parseModelString(override);
+	if (parsed) {
+		return { model: modelRegistry.find(parsed.provider, parsed.id) };
+	}
+
+	// Fall back to fuzzy pattern matching
+	const result = parseModelPattern(override, modelRegistry.getAvailable());
+	return {
+		model: result.model,
+		thinkingLevel: result.thinkingLevel !== "off" ? result.thinkingLevel : undefined,
+	};
+}
+
+/**
+ * Main task execution function.
+ *
+ * Equivalent to CLI flow:
+ * 1. omp --mode json --non-interactive
+ * 2. --append-system-prompt <agent.systemPrompt>
+ * 3. --tools <toolNames> (if specified)
+ * 4. --model <model> (if specified)
+ * 5. --session <sessionFile> OR --no-session
+ * 6. --prompt <task>
+ *
+ * Environment equivalent:
+ * - OMP_BLOCKED_AGENT: payload.blockedAgent (prevents same-agent recursion)
+ * - OMP_SPAWNS: payload.spawnsEnv (controls nested spawn permissions)
+ */
+async function runTask(payload: SubagentWorkerStartPayload): Promise<void> {
+	const startTime = Date.now();
+	let exitCode = 0;
+	let error: string | undefined;
+	let aborted = false;
+
+	try {
+		// Check for pre-start abort
+		if (abortRequested) {
+			aborted = true;
+			exitCode = 1;
+			return;
+		}
+
+		// Set working directory (CLI does this implicitly)
+		process.chdir(payload.cwd);
+
+		// Discover auth and models (equivalent to CLI's discoverAuthStorage/discoverModels)
+		const authStorage = await discoverAuthStorage();
+		const modelRegistry = await discoverModels(authStorage);
+
+		// Resolve model override (equivalent to CLI's parseModelPattern with --model)
+		const { model, thinkingLevel } = resolveModelOverride(payload.model, modelRegistry);
+
+		// Create session manager (equivalent to CLI's --session or --no-session)
+		const sessionManager = payload.sessionFile
+			? await SessionManager.open(payload.sessionFile)
+			: SessionManager.inMemory(payload.cwd);
+
+		// Create agent session (equivalent to CLI's createAgentSession)
+		// Note: hasUI: false disables interactive features
+		const { session } = await createAgentSession({
+			cwd: payload.cwd,
+			authStorage,
+			modelRegistry,
+			model,
+			thinkingLevel,
+			toolNames: payload.toolNames,
+			// Append system prompt (equivalent to CLI's --append-system-prompt)
+			systemPrompt: (defaultPrompt) => `${defaultPrompt}\n\n${payload.systemPrompt}`,
+			sessionManager,
+			hasUI: false,
+			// Pass spawn restrictions to nested tasks
+			spawns: payload.spawnsEnv,
+		});
+
+		activeSession = session;
+
+		// Initialize extensions (equivalent to CLI's extension initialization)
+		// Note: Does not support --extension CLI flag or extension CLI flags
+		const extensionRunner = session.extensionRunner;
+		if (extensionRunner) {
+			extensionRunner.initialize({
+				getModel: () => session.model,
+				sendMessageHandler: (message, options) => {
+					session.sendCustomMessage(message, options).catch((e) => {
+						console.error(`Extension sendMessage failed: ${e instanceof Error ? e.message : String(e)}`);
+					});
+				},
+				appendEntryHandler: (customType, data) => {
+					session.sessionManager.appendCustomEntry(customType, data);
+				},
+				getActiveToolsHandler: () => session.getActiveToolNames(),
+				getAllToolsHandler: () => session.getAllToolNames(),
+				setActiveToolsHandler: (toolNamesList: string[]) => session.setActiveToolsByName(toolNamesList),
+			});
+			extensionRunner.onError((err) => {
+				console.error(`Extension error (${err.extensionPath}): ${err.error}`);
+			});
+			await extensionRunner.emit({ type: "session_start" });
+		}
+
+		// Subscribe to events and forward to parent (equivalent to --mode json output)
+		session.subscribe((event: AgentSessionEvent) => {
+			if (isAgentEvent(event)) {
+				postMessageSafe({ type: "event", event });
+			}
+		});
+
+		// Run the prompt (equivalent to --prompt flag)
+		await session.prompt(payload.task);
+
+		// Check if aborted during execution
+		const lastMessage = session.state.messages[session.state.messages.length - 1];
+		if (lastMessage?.role === "assistant" && lastMessage.stopReason === "aborted") {
+			aborted = true;
+			exitCode = 1;
+		}
+	} catch (err) {
+		exitCode = 1;
+		error = err instanceof Error ? err.stack || err.message : String(err);
+	} finally {
+		// Handle abort requested during execution
+		if (abortRequested) {
+			aborted = true;
+			if (exitCode === 0) exitCode = 1;
+		}
+
+		// Cleanup session
+		if (activeSession) {
+			try {
+				await activeSession.dispose();
+			} catch {
+				// Ignore cleanup errors
+			}
+			activeSession = null;
+		}
+
+		// Send completion message to parent
+		postMessageSafe({
+			type: "done",
+			exitCode,
+			durationMs: Date.now() - startTime,
+			error,
+			aborted,
+		});
+	}
+}
+
+/** Handle abort request from parent */
+function handleAbort(): void {
+	abortRequested = true;
+	if (activeSession) {
+		void activeSession.abort();
+	}
+}
+
+// Message handler - receives start/abort commands from parent
+globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorkerRequest>) => {
+	const message = event.data;
+	if (!message) return;
+
+	if (message.type === "abort") {
+		handleAbort();
+		return;
+	}
+
+	if (message.type === "start") {
+		// Only allow one task per worker
+		if (running) return;
+		running = true;
+		void runTask(message.payload);
+	}
+});

package/src/core/tools/truncate.ts

@@ -5,7 +5,8 @@
  * - Line limit (default: 2000 lines)
  * - Byte limit (default: 50KB)
  *
- * Never returns partial lines (except bash tail truncation edge case).
+ * Never returns partial lines (except bash tail truncation edge case
+ * and the read tool's long-line snippet fallback).
  */
 
 export const DEFAULT_MAX_LINES = 2000;
@@ -250,6 +251,31 @@ function truncateStringToBytesFromEnd(str: string, maxBytes: number): string {
 	return buf.slice(start).toString("utf-8");
 }
 
+/**
+ * Truncate a string to fit within a byte limit (from the start).
+ * Handles multi-byte UTF-8 characters correctly.
+ */
+export function truncateStringToBytesFromStart(str: string, maxBytes: number): { text: string; bytes: number } {
+	const buf = Buffer.from(str, "utf-8");
+	if (buf.length <= maxBytes) {
+		return { text: str, bytes: buf.length };
+	}
+
+	let end = maxBytes;
+
+	// Find a valid UTF-8 boundary (start of a character)
+	while (end > 0 && (buf[end] & 0xc0) === 0x80) {
+		end--;
+	}
+
+	if (end <= 0) {
+		return { text: "", bytes: 0 };
+	}
+
+	const text = buf.slice(0, end).toString("utf-8");
+	return { text, bytes: Buffer.byteLength(text, "utf-8") };
+}
+
 /**
  * Truncate a single line to max characters, adding [truncated] suffix.
  * Used for grep match lines.

package/src/core/tools/web-fetch.ts

@@ -5,6 +5,7 @@ import { Type } from "@sinclair/typebox";
 import { parse as parseHtml } from "node-html-parser";
 import webFetchDescription from "../../prompts/tools/web-fetch.md" with { type: "text" };
 import { logger } from "../logger";
+import type { ToolSession } from "./index";
 
 // =============================================================================
 // Types and Constants
@@ -66,8 +67,6 @@ const CONVERTIBLE_EXTENSIONS = new Set([
 	".ogg",
 ]);
 
-const isWindows = process.platform === "win32";
-
 const USER_AGENTS = [
 	"curl/8.0",
 	"Mozilla/5.0 (compatible; TextBot/1.0)",
@@ -211,13 +210,7 @@ function exec(
  * Check if a command exists (cross-platform)
  */
 function hasCommand(cmd: string): boolean {
-	const checkCmd = isWindows ? "where" : "which";
-	const result = Bun.spawnSync([checkCmd, cmd], {
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-	return result.exitCode === 0;
+	return Boolean(Bun.which(cmd));
 }
 
 /**
@@ -626,7 +619,18 @@ async function fetchBinary(
 
 		const contentType = response.headers.get("content-type") ?? "";
 		const contentDisposition = response.headers.get("content-disposition") ?? undefined;
+		const contentLength = response.headers.get("content-length");
+		if (contentLength) {
+			const size = Number.parseInt(contentLength, 10);
+			if (Number.isFinite(size) && size > MAX_BYTES) {
+				return { buffer: Buffer.alloc(0), contentType, contentDisposition, ok: false };
+			}
+		}
+
 		const buffer = Buffer.from(await response.arrayBuffer());
+		if (buffer.length > MAX_BYTES) {
+			return { buffer: Buffer.alloc(0), contentType, contentDisposition, ok: false };
+		}
 
 		return { buffer, contentType, contentDisposition, ok: true };
 	} catch {
@@ -1236,9 +1240,7 @@ async function handleStackOverflow(url: string, timeout: number): Promise<Render
 		md += `**Score:** ${question.score} · **Answers:** ${question.answer_count}`;
 		md += question.is_answered ? " (Answered)" : "";
 		md += `\n**Tags:** ${question.tags.join(", ")}\n`;
-		md += `**Asked by:** ${question.owner.display_name} · ${
-			new Date(question.creation_date * 1000).toISOString().split("T")[0]
-		}\n\n`;
+		md += `**Asked by:** ${question.owner.display_name} · ${new Date(question.creation_date * 1000).toISOString().split("T")[0]}\n\n`;
 		md += `---\n\n## Question\n\n${htmlToBasicMarkdown(question.body)}\n\n`;
 
 		// Fetch answers
@@ -1959,16 +1961,16 @@ async function renderUrl(url: string, timeout: number, raw: boolean = false): Pr
 	const notes: string[] = [];
 	const fetchedAt = new Date().toISOString();
 
-	// Step 0: Try special handlers for known sites (unless raw mode)
+	// Step 0: Normalize URL (ensure scheme for special handlers)
+	url = normalizeUrl(url);
+	const origin = getOrigin(url);
+
+	// Step 1: Try special handlers for known sites (unless raw mode)
 	if (!raw) {
 		const specialResult = await handleSpecialUrls(url, timeout);
 		if (specialResult) return specialResult;
 	}
 
-	// Step 1: Normalize URL
-	url = normalizeUrl(url);
-	const origin = getOrigin(url);
-
 	// Step 2: Fetch page
 	const response = await loadPage(url, { timeout });
 	if (!response.ok) {
@@ -2267,10 +2269,10 @@ export interface WebFetchToolDetails {
 	notes: string[];
 }
 
-export function createWebFetchTool(_cwd: string): AgentTool<typeof webFetchSchema> {
+export function createWebFetchTool(_session: ToolSession): AgentTool<typeof webFetchSchema> {
 	return {
 		name: "web_fetch",
-		label: "web_fetch",
+		label: "Web Fetch",
 		description: webFetchDescription,
 		parameters: webFetchSchema,
 		execute: async (
@@ -2313,9 +2315,6 @@ export function createWebFetchTool(_cwd: string): AgentTool<typeof webFetchSchem
 	};
 }
 
-/** Default web fetch tool using process.cwd() - for backwards compatibility */
-export const webFetchTool = createWebFetchTool(process.cwd());
-
 // =============================================================================
 // TUI Rendering
 // =============================================================================
@@ -2323,7 +2322,7 @@ export const webFetchTool = createWebFetchTool(process.cwd());
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { type Theme, theme } from "../../modes/interactive/theme/theme";
-import type { CustomTool, CustomToolContext, RenderResultOptions } from "../custom-tools/types";
+import type { RenderResultOptions } from "../custom-tools/types";
 
 /** Truncate text to max length with ellipsis */
 function truncate(text: string, maxLen: number, ellipsis: string): string {
@@ -2483,30 +2482,7 @@ export function renderWebFetchResult(
 	return new Text(text, 0, 0);
 }
 
-type WebFetchParams = { url: string; timeout?: number; raw?: boolean };
-
-/** Web fetch tool as CustomTool (for TUI rendering support) */
-export const webFetchCustomTool: CustomTool<typeof webFetchSchema, WebFetchToolDetails> = {
-	name: "web_fetch",
-	label: "Web Fetch",
-	description: webFetchDescription,
-	parameters: webFetchSchema,
-
-	async execute(
-		toolCallId: string,
-		params: WebFetchParams,
-		_onUpdate,
-		_ctx: CustomToolContext,
-		_signal?: AbortSignal,
-	) {
-		return webFetchTool.execute(toolCallId, params);
-	},
-
-	renderCall(args: WebFetchParams, uiTheme: Theme) {
-		return renderWebFetchCall(args, uiTheme);
-	},
-
-	renderResult(result, options: RenderResultOptions, uiTheme: Theme) {
-		return renderWebFetchResult(result, options, uiTheme);
-	},
+export const webFetchToolRenderer = {
+	renderCall: renderWebFetchCall,
+	renderResult: renderWebFetchResult,
 };

package/src/core/tools/web-search/index.ts

@@ -20,12 +20,15 @@ import type { CustomTool, CustomToolContext, RenderResultOptions } from "../../c
 import { callExaTool, findApiKey as findExaKey, formatSearchResults, isSearchResponse } from "../exa/mcp-client";
 import { renderExaCall, renderExaResult } from "../exa/render";
 import type { ExaRenderDetails } from "../exa/types";
+import type { ToolSession } from "../index";
 import { formatAge } from "../render-utils";
+import { findAnthropicAuth } from "./auth";
 import { searchAnthropic } from "./providers/anthropic";
 import { searchExa } from "./providers/exa";
 import { findApiKey as findPerplexityKey, searchPerplexity } from "./providers/perplexity";
 import { renderWebSearchCall, renderWebSearchResult, type WebSearchRenderDetails } from "./render";
 import type { WebSearchProvider, WebSearchResponse } from "./types";
+import { WebSearchProviderError } from "./types";
 
 /** Web search parameters schema */
 export const webSearchSchema = Type.Object({
@@ -95,18 +98,78 @@ export type WebSearchParams = {
 	return_related_questions?: boolean;
 };
 
-/** Detect provider based on available API keys (priority: exa > perplexity > anthropic) */
-async function detectProvider(): Promise<WebSearchProvider> {
-	// Exa takes highest priority if key exists
+/** Preferred provider set via settings (default: auto) */
+let preferredProvider: WebSearchProvider | "auto" = "auto";
+
+/** Set the preferred web search provider from settings */
+export function setPreferredWebSearchProvider(provider: WebSearchProvider | "auto"): void {
+	preferredProvider = provider;
+}
+
+/** Determine which providers are configured (priority order) */
+async function getAvailableProviders(): Promise<WebSearchProvider[]> {
+	const providers: WebSearchProvider[] = [];
+
 	const exaKey = await findExaKey();
-	if (exaKey) return "exa";
+	if (exaKey) providers.push("exa");
 
-	// Perplexity second priority
 	const perplexityKey = await findPerplexityKey();
-	if (perplexityKey) return "perplexity";
+	if (perplexityKey) providers.push("perplexity");
+
+	const anthropicAuth = await findAnthropicAuth();
+	if (anthropicAuth) providers.push("anthropic");
+
+	return providers;
+}
+
+function formatProviderLabel(provider: WebSearchProvider): string {
+	switch (provider) {
+		case "exa":
+			return "Exa";
+		case "perplexity":
+			return "Perplexity";
+		case "anthropic":
+			return "Anthropic";
+		default:
+			return provider;
+	}
+}
+
+function formatProviderList(providers: WebSearchProvider[]): string {
+	return providers.map((provider) => formatProviderLabel(provider)).join(", ");
+}
+
+function buildNoProviderError(): string {
+	return "No web search provider configured. Set EXA_API_KEY, PERPLEXITY_API_KEY, ANTHROPIC_SEARCH_API_KEY, or ANTHROPIC_API_KEY.";
+}
+
+function formatProviderError(error: unknown, provider: WebSearchProvider): string {
+	if (error instanceof WebSearchProviderError) {
+		if (error.provider === "anthropic" && error.status === 404) {
+			return "Anthropic web search returned 404 (model or endpoint not found). Set ANTHROPIC_SEARCH_MODEL/ANTHROPIC_SEARCH_BASE_URL, or configure EXA_API_KEY or PERPLEXITY_API_KEY.";
+		}
+		if (error.status === 401 || error.status === 403) {
+			return `${formatProviderLabel(error.provider)} authorization failed (${error.status}). Check API key or base URL.`;
+		}
+		return error.message;
+	}
+	if (error instanceof Error) return error.message;
+	return `Unknown error from ${formatProviderLabel(provider)}`;
+}
+
+async function resolveProviderChain(
+	requestedProvider?: WebSearchProvider | "auto",
+): Promise<{ providers: WebSearchProvider[]; allowFallback: boolean }> {
+	if (requestedProvider && requestedProvider !== "auto") {
+		return { providers: [requestedProvider], allowFallback: false };
+	}
+
+	if (preferredProvider !== "auto") {
+		return { providers: [preferredProvider], allowFallback: false };
+	}
 
-	// Default to Anthropic
-	return "anthropic";
+	const providers = await getAvailableProviders();
+	return { providers, allowFallback: true };
 }
 
 /** Truncate text for tool output */
@@ -198,48 +261,71 @@ async function executeWebSearch(
 	_toolCallId: string,
 	params: WebSearchParams,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: WebSearchRenderDetails }> {
-	try {
-		const provider = params.provider && params.provider !== "auto" ? params.provider : await detectProvider();
-
-		let response: WebSearchResponse;
-		if (provider === "exa") {
-			response = await searchExa({
-				query: params.query,
-				num_results: params.num_results,
-			});
-		} else if (provider === "anthropic") {
-			response = await searchAnthropic({
-				query: params.query,
-				system_prompt: params.system_prompt,
-				max_tokens: params.max_tokens,
-				num_results: params.num_results,
-			});
-		} else {
-			response = await searchPerplexity({
-				query: params.query,
-				model: params.model,
-				system_prompt: params.system_prompt,
-				search_recency_filter: params.search_recency_filter,
-				search_domain_filter: params.search_domain_filter,
-				search_context_size: params.search_context_size,
-				return_related_questions: params.return_related_questions,
-				num_results: params.num_results,
-			});
-		}
+	const { providers, allowFallback } = await resolveProviderChain(params.provider);
 
-		const text = formatForLLM(response);
-
-		return {
-			content: [{ type: "text" as const, text }],
-			details: { response },
-		};
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
+	if (providers.length === 0) {
+		const message = buildNoProviderError();
+		const fallbackProvider = preferredProvider === "auto" ? "anthropic" : preferredProvider;
 		return {
 			content: [{ type: "text" as const, text: `Error: ${message}` }],
-			details: { response: { provider: "anthropic", sources: [] }, error: message },
+			details: { response: { provider: fallbackProvider, sources: [] }, error: message },
 		};
 	}
+
+	let lastError: unknown;
+	let lastProvider = providers[0];
+
+	for (const provider of providers) {
+		lastProvider = provider;
+		try {
+			let response: WebSearchResponse;
+			if (provider === "exa") {
+				response = await searchExa({
+					query: params.query,
+					num_results: params.num_results,
+				});
+			} else if (provider === "anthropic") {
+				response = await searchAnthropic({
+					query: params.query,
+					system_prompt: params.system_prompt,
+					max_tokens: params.max_tokens,
+					num_results: params.num_results,
+				});
+			} else {
+				response = await searchPerplexity({
+					query: params.query,
+					model: params.model,
+					system_prompt: params.system_prompt,
+					search_recency_filter: params.search_recency_filter,
+					search_domain_filter: params.search_domain_filter,
+					search_context_size: params.search_context_size,
+					return_related_questions: params.return_related_questions,
+					num_results: params.num_results,
+				});
+			}
+
+			const text = formatForLLM(response);
+
+			return {
+				content: [{ type: "text" as const, text }],
+				details: { response },
+			};
+		} catch (error) {
+			lastError = error;
+			if (!allowFallback) break;
+		}
+	}
+
+	const baseMessage = formatProviderError(lastError, lastProvider);
+	const message =
+		allowFallback && providers.length > 1
+			? `All web search providers failed (${formatProviderList(providers)}). Last error: ${baseMessage}`
+			: baseMessage;
+
+	return {
+		content: [{ type: "text" as const, text: `Error: ${message}` }],
+		details: { response: { provider: lastProvider, sources: [] }, error: message },
+	};
 }
 
 /** Web search tool as AgentTool (for allTools export) */
@@ -280,7 +366,7 @@ export const webSearchCustomTool: CustomTool<typeof webSearchSchema, WebSearchRe
 };
 
 /** Factory function for backward compatibility */
-export function createWebSearchTool(_cwd: string): AgentTool<typeof webSearchSchema> {
+export function createWebSearchTool(_session: ToolSession): AgentTool<typeof webSearchSchema> {
 	return webSearchTool;
 }
 

package/src/core/tools/web-search/providers/anthropic.ts

@@ -14,8 +14,9 @@ import type {
 	WebSearchResponse,
 	WebSearchSource,
 } from "../types";
+import { WebSearchProviderError } from "../types";
 
-const DEFAULT_MODEL = "claude-sonnet-4-5-20250514";
+const DEFAULT_MODEL = "claude-haiku-4-5";
 const DEFAULT_MAX_TOKENS = 4096;
 
 export interface AnthropicSearchParams {
@@ -80,7 +81,11 @@ async function callWebSearch(
 
 	if (!response.ok) {
 		const errorText = await response.text();
-		throw new Error(`Anthropic API error (${response.status}): ${errorText}`);
+		throw new WebSearchProviderError(
+			"anthropic",
+			`Anthropic API error (${response.status}): ${errorText}`,
+			response.status,
+		);
 	}
 
 	return response.json() as Promise<AnthropicApiResponse>;

package/src/core/tools/web-search/providers/exa.ts

@@ -8,6 +8,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import type { WebSearchResponse, WebSearchSource } from "../types";
+import { WebSearchProviderError } from "../types";
 
 const EXA_API_URL = "https://api.exa.ai/search";
 
@@ -142,7 +143,7 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 
 	if (!response.ok) {
 		const errorText = await response.text();
-		throw new Error(`Exa API error (${response.status}): ${errorText}`);
+		throw new WebSearchProviderError("exa", `Exa API error (${response.status}): ${errorText}`, response.status);
 	}
 
 	return response.json() as Promise<ExaSearchResponse>;