@oh-my-pi/pi-coding-agent 11.0.3 → 11.2.0

package/src/web/search/index.ts

@@ -1,8 +1,8 @@
 /**
  * Unified Web Search Tool
  *
- * Single tool supporting Anthropic, Perplexity, Exa, and Jina providers with
- * provider-specific parameters exposed conditionally.
+ * Single tool supporting Anthropic, Perplexity, Exa, Jina, Gemini, and Codex
+ * providers with provider-specific parameters exposed conditionally.
  *
  * When EXA_API_KEY is available, additional specialized tools are exposed:
  * - web_search_deep: Natural language web search with synthesized results
@@ -24,20 +24,16 @@ import webSearchSystemPrompt from "../../prompts/system/web-search.md" with { ty
 import webSearchDescription from "../../prompts/tools/web-search.md" with { type: "text" };
 import type { ToolSession } from "../../tools";
 import { formatAge } from "../../tools/render-utils";
-import { findAnthropicAuth } from "./auth";
-import { searchAnthropic } from "./providers/anthropic";
-import { searchExa } from "./providers/exa";
-import { findApiKey as findJinaKey, searchJina } from "./providers/jina";
-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";
+import { getSearchProvider, resolveProviderChain, type SearchProvider } from "./provider";
+import { renderSearchCall, renderSearchResult, type SearchRenderDetails } from "./render";
+import type { SearchResponse } from "./types";
+import { SearchProviderError } from "./types";
 
 /** Web search parameters schema */
 export const webSearchSchema = Type.Object({
 	query: Type.String({ description: "Search query" }),
 	provider: Type.Optional(
-		StringEnum(["auto", "exa", "jina", "anthropic", "perplexity"], {
+		StringEnum(["auto", "exa", "jina", "anthropic", "perplexity", "gemini", "codex"], {
 			description: "Search provider (default: auto)",
 		}),
 	),
@@ -49,86 +45,35 @@ export const webSearchSchema = Type.Object({
 	limit: Type.Optional(Type.Number({ description: "Max results to return" })),
 });
 
-export type WebSearchParams = {
+export type SearchParams = {
 	query: string;
-	provider?: "auto" | "exa" | "jina" | "anthropic" | "perplexity";
+	provider?: "auto" | "exa" | "jina" | "anthropic" | "perplexity" | "gemini" | "codex";
 	recency?: "day" | "week" | "month" | "year";
 	limit?: number;
+	/** Maximum output tokens. Defaults to 4096. */
+	max_tokens?: number;
+	/** Sampling temperature (0–1). Lower = more focused/factual. Defaults to 0.2. */
+	temperature?: number;
+	/** Number of search results to retrieve. Defaults to 10. */
+	num_search_results?: number;
 };
 
-/** 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) providers.push("exa");
-
-	const jinaKey = await findJinaKey();
-	if (jinaKey) providers.push("jina");
-
-	const perplexityKey = await findPerplexityKey();
-	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 "jina":
-			return "Jina";
-		case "perplexity":
-			return "Perplexity";
-		case "anthropic":
-			return "Anthropic";
-		default:
-			return provider;
-	}
-}
-
-function formatProviderList(providers: WebSearchProvider[]): string {
-	return providers.map(provider => formatProviderLabel(provider)).join(", ");
+function formatProviderList(providers: SearchProvider[]): string {
+	return providers.map(provider => provider.label).join(", ");
 }
 
-function formatProviderError(error: unknown, provider: WebSearchProvider): string {
-	if (error instanceof WebSearchProviderError) {
+function formatProviderError(error: unknown, provider: SearchProvider): string {
+	if (error instanceof SearchProviderError) {
 		if (error.provider === "anthropic" && error.status === 404) {
 			return "Anthropic web search returned 404 (model or endpoint not found).";
 		}
 		if (error.status === 401 || error.status === 403) {
-			return `${formatProviderLabel(error.provider)} authorization failed (${error.status}). Check API key or base URL.`;
+			return `${getSearchProvider(error.provider).label} 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 };
-	}
-
-	const providers = await getAvailableProviders();
-	return { providers, allowFallback: true };
+	return `Unknown error from ${provider.label}`;
 }
 
 /** Truncate text for tool output */
@@ -142,7 +87,7 @@ function formatCount(label: string, count: number): string {
 }
 
 /** Format response for LLM consumption */
-function formatForLLM(response: WebSearchResponse): string {
+function formatForLLM(response: SearchResponse): string {
 	const parts: string[] = [];
 
 	parts.push("## Answer");
@@ -216,18 +161,17 @@ function formatForLLM(response: WebSearchResponse): string {
 }
 
 /** Execute web search */
-async function executeWebSearch(
+async function executeSearch(
 	_toolCallId: string,
-	params: WebSearchParams,
-): Promise<{ content: Array<{ type: "text"; text: string }>; details: WebSearchRenderDetails }> {
-	const { providers, allowFallback } = await resolveProviderChain(params.provider);
+	params: SearchParams,
+): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
+	const providers = await resolveProviderChain(params.provider);
 
 	if (providers.length === 0) {
 		const message = "No web search provider configured.";
-		const fallbackProvider = preferredProvider === "auto" ? "anthropic" : preferredProvider;
 		return {
 			content: [{ type: "text" as const, text: `Error: ${message}` }],
-			details: { response: { provider: fallbackProvider, sources: [] }, error: message },
+			details: { response: { provider: "none", sources: [] }, error: message },
 		};
 	}
 
@@ -237,31 +181,15 @@ async function executeWebSearch(
 	for (const provider of providers) {
 		lastProvider = provider;
 		try {
-			let response: WebSearchResponse;
-			if (provider === "exa") {
-				response = await searchExa({
-					query: params.query,
-					num_results: params.limit,
-				});
-			} else if (provider === "jina") {
-				response = await searchJina({
-					query: params.query,
-					num_results: params.limit,
-				});
-			} else if (provider === "anthropic") {
-				response = await searchAnthropic({
-					query: params.query,
-					system_prompt: webSearchSystemPrompt,
-					num_results: params.limit,
-				});
-			} else {
-				response = await searchPerplexity({
-					query: params.query,
-					system_prompt: webSearchSystemPrompt,
-					search_recency_filter: params.recency,
-					num_results: params.limit,
-				});
-			}
+			const response = await provider.search({
+				query: params.query.replace(/202\d/g, String(new Date().getFullYear())), // LUL
+				limit: params.limit,
+				recency: params.recency,
+				systemPrompt: webSearchSystemPrompt,
+				maxOutputTokens: params.max_tokens,
+				numSearchResults: params.num_search_results,
+				temperature: params.temperature,
+			});
 
 			const text = formatForLLM(response);
 
@@ -271,29 +199,37 @@ async function executeWebSearch(
 			};
 		} catch (error) {
 			lastError = error;
-			if (!allowFallback) break;
 		}
 	}
 
 	const baseMessage = formatProviderError(lastError, lastProvider);
 	const message =
-		allowFallback && providers.length > 1
+		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 },
+		details: { response: { provider: lastProvider.id, sources: [] }, error: message },
 	};
 }
 
+/**
+ * Execute a web search query for CLI/testing workflows.
+ */
+export async function runSearchQuery(
+	params: SearchParams,
+): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
+	return executeSearch("cli-web-search", params);
+}
+
 /**
  * Web search tool implementation.
  *
- * Supports Anthropic, Perplexity, Exa, and Jina providers with automatic fallback.
+ * Supports Anthropic, Perplexity, Exa, Jina, Gemini, and Codex providers with automatic fallback.
  * Session is accepted for interface consistency but not used.
  */
-export class WebSearchTool implements AgentTool<typeof webSearchSchema, WebSearchRenderDetails> {
+export class SearchTool implements AgentTool<typeof webSearchSchema, SearchRenderDetails> {
 	public readonly name = "web_search";
 	public readonly label = "Web Search";
 	public readonly description: string;
@@ -305,38 +241,32 @@ export class WebSearchTool implements AgentTool<typeof webSearchSchema, WebSearc
 
 	public async execute(
 		_toolCallId: string,
-		params: WebSearchParams,
+		params: SearchParams,
 		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<WebSearchRenderDetails>,
+		_onUpdate?: AgentToolUpdateCallback<SearchRenderDetails>,
 		_context?: AgentToolContext,
-	): Promise<AgentToolResult<WebSearchRenderDetails>> {
-		return executeWebSearch(_toolCallId, params);
+	): Promise<AgentToolResult<SearchRenderDetails>> {
+		return executeSearch(_toolCallId, params);
 	}
 }
 
 /** Web search tool as CustomTool (for TUI rendering support) */
-export const webSearchCustomTool: CustomTool<typeof webSearchSchema, WebSearchRenderDetails> = {
+export const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails> = {
 	name: "web_search",
 	label: "Web Search",
 	description: renderPromptTemplate(webSearchDescription),
 	parameters: webSearchSchema,
 
-	async execute(
-		toolCallId: string,
-		params: WebSearchParams,
-		_onUpdate,
-		_ctx: CustomToolContext,
-		_signal?: AbortSignal,
-	) {
-		return executeWebSearch(toolCallId, params);
+	async execute(toolCallId: string, params: SearchParams, _onUpdate, _ctx: CustomToolContext, _signal?: AbortSignal) {
+		return executeSearch(toolCallId, params);
 	},
 
-	renderCall(args: WebSearchParams, theme: Theme) {
-		return renderWebSearchCall(args, theme);
+	renderCall(args: SearchParams, theme: Theme) {
+		return renderSearchCall(args, theme);
 	},
 
 	renderResult(result, options: RenderResultOptions, theme: Theme) {
-		return renderWebSearchResult(result, options, theme);
+		return renderSearchResult(result, options, theme);
 	},
 };
 
@@ -582,19 +512,19 @@ Parameters:
 };
 
 /** All Exa-specific web search tools */
-export const exaWebSearchTools: CustomTool<any, ExaRenderDetails>[] = [
+export const exaSearchTools: CustomTool<any, ExaRenderDetails>[] = [
 	webSearchDeepTool,
 	webSearchCodeContextTool,
 	webSearchCrawlTool,
 ];
 
 /** LinkedIn-specific tool (requires LinkedIn addon on Exa account) */
-export const linkedinWebSearchTools: CustomTool<any, ExaRenderDetails>[] = [webSearchLinkedinTool];
+export const linkedinSearchTools: CustomTool<any, ExaRenderDetails>[] = [webSearchLinkedinTool];
 
 /** Company-specific tool (requires Company addon on Exa account) */
-export const companyWebSearchTools: CustomTool<any, ExaRenderDetails>[] = [webSearchCompanyTool];
+export const companySearchTools: CustomTool<any, ExaRenderDetails>[] = [webSearchCompanyTool];
 
-export interface WebSearchToolsOptions {
+export interface SearchToolsOptions {
 	/** Enable LinkedIn search tool (requires Exa LinkedIn addon) */
 	enableLinkedin?: boolean;
 	/** Enable company research tool (requires Exa Company addon) */
@@ -610,19 +540,19 @@ export interface WebSearchToolsOptions {
  * - With EXA_API_KEY + options.enableLinkedin: web_search_linkedin
  * - With EXA_API_KEY + options.enableCompany: web_search_company
  */
-export async function getWebSearchTools(options: WebSearchToolsOptions = {}): Promise<CustomTool<any, any>[]> {
+export async function getSearchTools(options: SearchToolsOptions = {}): Promise<CustomTool<any, any>[]> {
 	const tools: CustomTool<any, any>[] = [webSearchCustomTool];
 
 	// Check for Exa API key
 	const exaKey = await findExaKey();
 	if (exaKey) {
-		tools.push(...exaWebSearchTools);
+		tools.push(...exaSearchTools);
 
 		if (options.enableLinkedin) {
-			tools.push(...linkedinWebSearchTools);
+			tools.push(...linkedinSearchTools);
 		}
 		if (options.enableCompany) {
-			tools.push(...companyWebSearchTools);
+			tools.push(...companySearchTools);
 		}
 	}
 
@@ -632,9 +562,13 @@ export async function getWebSearchTools(options: WebSearchToolsOptions = {}): Pr
 /**
  * Check if Exa-specific web search tools are available.
  */
-export async function hasExaWebSearch(): Promise<boolean> {
+export async function hasExaSearch(): Promise<boolean> {
 	const exaKey = await findExaKey();
 	return exaKey !== null;
 }
 
-export type { WebSearchProvider, WebSearchResponse } from "./types";
+export {
+	getSearchProvider,
+	setPreferredSearchProvider,
+} from "./provider";
+export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";

package/src/web/search/provider.ts

@@ -0,0 +1,58 @@
+import { AnthropicProvider } from "./providers/anthropic";
+import type { SearchProvider } from "./providers/base";
+import { CodexProvider } from "./providers/codex";
+import { ExaProvider } from "./providers/exa";
+import { GeminiProvider } from "./providers/gemini";
+import { JinaProvider } from "./providers/jina";
+import { PerplexityProvider } from "./providers/perplexity";
+import type { SearchProviderId } from "./types";
+
+export type { SearchParams } from "./providers/base";
+export { SearchProvider } from "./providers/base";
+
+const SEARCH_PROVIDERS: Record<SearchProviderId, SearchProvider> = {
+	exa: new ExaProvider(),
+	jina: new JinaProvider(),
+	perplexity: new PerplexityProvider(),
+	anthropic: new AnthropicProvider(),
+	gemini: new GeminiProvider(),
+	codex: new CodexProvider(),
+} as const;
+
+const SEARCH_PROVIDER_ORDER: SearchProviderId[] = ["exa", "jina", "perplexity", "anthropic", "gemini", "codex"];
+
+export function getSearchProvider(provider: SearchProviderId): SearchProvider {
+	return SEARCH_PROVIDERS[provider];
+}
+
+/** Preferred provider set via settings (default: auto) */
+let preferredProvId: SearchProviderId | "auto" = "auto";
+
+/** Set the preferred web search provider from settings */
+export function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void {
+	preferredProvId = provider;
+}
+
+/** Determine which providers are configured (priority order) */
+export async function resolveProviderChain(
+	preferredProvider: SearchProviderId | "auto" = preferredProvId,
+): Promise<SearchProvider[]> {
+	const providers: SearchProvider[] = [];
+
+	if (preferredProvider !== "auto") {
+		if (await getSearchProvider(preferredProvider).isAvailable()) {
+			providers.push(getSearchProvider(preferredProvider));
+		}
+	}
+
+	for (const id of SEARCH_PROVIDER_ORDER) {
+		if (id === preferredProvider) continue;
+
+		const provider = getSearchProvider(id);
+		if (await provider.isAvailable()) {
+			providers.push(provider);
+		}
+	}
+
+	return providers;
+}

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

@@ -11,11 +11,13 @@ import type {
 	AnthropicApiResponse,
 	AnthropicAuthConfig,
 	AnthropicCitation,
-	WebSearchCitation,
-	WebSearchResponse,
-	WebSearchSource,
+	SearchCitation,
+	SearchResponse,
+	SearchSource,
 } from "../../../web/search/types";
-import { WebSearchProviderError } from "../../../web/search/types";
+import { SearchProviderError } from "../../../web/search/types";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
 
 const DEFAULT_MODEL = "claude-haiku-4-5";
 const DEFAULT_MAX_TOKENS = 4096;
@@ -36,6 +38,10 @@ export interface AnthropicSearchParams {
 	query: string;
 	system_prompt?: string;
 	num_results?: number;
+	/** Maximum output tokens. Defaults to 4096. */
+	max_tokens?: number;
+	/** Sampling temperature (0–1). Lower = more focused/factual. */
+	temperature?: number;
 }
 
 /**
@@ -74,13 +80,15 @@ function buildSystemBlocks(
  * @param query - Search query from the user
  * @param systemPrompt - Optional system prompt for guiding response style
  * @returns Raw API response from Anthropic
- * @throws {WebSearchProviderError} If the API request fails
+ * @throws {SearchProviderError} If the API request fails
  */
-async function callWebSearch(
+async function callSearch(
 	auth: AnthropicAuthConfig,
 	model: string,
 	query: string,
 	systemPrompt?: string,
+	maxTokens?: number,
+	temperature?: number,
 ): Promise<AnthropicApiResponse> {
 	const url = buildAnthropicUrl(auth);
 	const headers = buildAnthropicHeaders(auth);
@@ -89,7 +97,7 @@ async function callWebSearch(
 
 	const body: Record<string, unknown> = {
 		model,
-		max_tokens: DEFAULT_MAX_TOKENS,
+		max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
 		messages: [{ role: "user", content: query }],
 		tools: [
 			{
@@ -99,6 +107,10 @@ async function callWebSearch(
 		],
 	};
 
+	if (temperature !== undefined) {
+		body.temperature = temperature;
+	}
+
 	if (systemBlocks && systemBlocks.length > 0) {
 		body.system = systemBlocks;
 	}
@@ -111,7 +123,7 @@ async function callWebSearch(
 
 	if (!response.ok) {
 		const errorText = await response.text();
-		throw new WebSearchProviderError(
+		throw new SearchProviderError(
 			"anthropic",
 			`Anthropic API error (${response.status}): ${errorText}`,
 			response.status,
@@ -158,15 +170,15 @@ function parsePageAge(pageAge: string | null | undefined): number | undefined {
 }
 
 /**
- * Parses the Anthropic API response into a unified WebSearchResponse.
+ * Parses the Anthropic API response into a unified SearchResponse.
  * @param response - Raw API response containing content blocks
  * @returns Normalized response with answer, sources, citations, and usage
  */
-function parseResponse(response: AnthropicApiResponse): WebSearchResponse {
+function parseResponse(response: AnthropicApiResponse): SearchResponse {
 	const answerParts: string[] = [];
 	const searchQueries: string[] = [];
-	const sources: WebSearchSource[] = [];
-	const citations: WebSearchCitation[] = [];
+	const sources: SearchSource[] = [];
+	const citations: SearchCitation[] = [];
 
 	for (const block of response.content) {
 		if (
@@ -228,7 +240,7 @@ function parseResponse(response: AnthropicApiResponse): WebSearchResponse {
  * @returns Search response with synthesized answer, sources, and citations
  * @throws {Error} If no Anthropic credentials are configured
  */
-export async function searchAnthropic(params: AnthropicSearchParams): Promise<WebSearchResponse> {
+export async function searchAnthropic(params: AnthropicSearchParams): Promise<SearchResponse> {
 	const auth = await findAnthropicAuth();
 	if (!auth) {
 		throw new Error(
@@ -237,7 +249,14 @@ export async function searchAnthropic(params: AnthropicSearchParams): Promise<We
 	}
 
 	const model = getModel();
-	const response = await callWebSearch(auth, model, params.query, params.system_prompt);
+	const response = await callSearch(
+		auth,
+		model,
+		params.query,
+		params.system_prompt,
+		params.max_tokens,
+		params.temperature,
+	);
 
 	const result = parseResponse(response);
 
@@ -248,3 +267,23 @@ export async function searchAnthropic(params: AnthropicSearchParams): Promise<We
 
 	return result;
 }
+
+/** Search provider for Anthropic Claude web search. */
+export class AnthropicProvider extends SearchProvider {
+	readonly id = "anthropic";
+	readonly label = "Anthropic";
+
+	isAvailable() {
+		return findAnthropicAuth().then(Boolean);
+	}
+
+	search(params: SearchParams): Promise<SearchResponse> {
+		return searchAnthropic({
+			query: params.query,
+			system_prompt: params.systemPrompt,
+			num_results: params.numSearchResults ?? params.limit,
+			max_tokens: params.maxOutputTokens,
+			temperature: params.temperature,
+		});
+	}
+}

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

@@ -0,0 +1,22 @@
+import type { SearchProviderId, SearchResponse } from "../types";
+
+/** Shared web search parameters passed to providers. */
+export interface SearchParams {
+	query: string;
+	limit?: number;
+	recency?: "day" | "week" | "month" | "year";
+	systemPrompt: string;
+	signal?: AbortSignal;
+	maxOutputTokens?: number;
+	numSearchResults?: number;
+	temperature?: number;
+}
+
+/** Base class for web search providers. */
+export abstract class SearchProvider {
+	abstract readonly id: SearchProviderId;
+	abstract readonly label: string;
+
+	abstract isAvailable(): Promise<boolean> | boolean;
+	abstract search(params: SearchParams): Promise<SearchResponse>;
+}