pi-all-search 1.0.2

package/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Upgrade npm
+        run: npm install -g npm@latest && npm config set registry https://registry.npmjs.org/
+
+      - name: Publish
+        run: npm publish --access public

package/README.md

@@ -0,0 +1,57 @@
+# pi-all-search
+
+**All-in-one web search extension for Pi — exa, tavily, anysearch, firecrawl, brave.**
+
+## Install
+
+```bash
+pi install npm:pi-all-search
+```
+
+## Configure
+
+Set API keys in environment or `~/.pi/web-search.json`:
+
+```json
+{
+  "exaApiKey": "exa-...",
+  "tavilyApiKey": "tvly-...",
+  "anysearchApiKey": "as_sk_...",
+  "firecrawlApiKey": "fc-...",
+  "braveApiKey": "BSA_..."
+}
+```
+
+Or set environment variables: `EXA_API_KEY`, `TAVILY_API_KEY`, `ANYSEARCH_API_KEY`, `FIRECRAWL_API_KEY`, `BRAVE_API_KEY`.
+
+## Usage
+
+```
+web_search({ query: "TypeScript best practices" })
+web_search({ queries: ["React vs Vue", "Angular vs Svelte"] })
+web_search({ query: "AAPL stock price", provider: "anysearch" })
+web_search({ query: "rust async programming", provider: "tavily" })
+```
+
+## Providers
+
+| Provider | Best For | Env Var |
+|----------|----------|---------|
+| **exa** | Academic papers, scholarly search | `EXA_API_KEY` |
+| **tavily** | General web, programming, fast results | `TAVILY_API_KEY` |
+| **anysearch** | Finance, stocks, structured data | `ANYSEARCH_API_KEY` |
+| **firecrawl** | Scraping-heavy sites, fallback | `FIRECRAWL_API_KEY` |
+| **brave** | General web, good coverage | `BRAVE_API_KEY` |
+
+## Routing
+
+Automatic intent-based routing:
+- **Finance queries** → anysearch → brave → exa
+- **Academic queries** → exa → anysearch → brave
+- **General queries** → tavily → brave → exa → anysearch
+
+Override with `provider="exa"` etc.
+
+## License
+
+MIT

package/extensions/index.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerWebSearchTool } from "./src/web-search.js";
+
+export default function (pi: ExtensionAPI) {
+  registerWebSearchTool(pi);
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "pi-all-search",
+  "version": "1.0.2",
+  "description": "All-in-one search extension for Pi — exa, tavily, anysearch, firecrawl, brave",
+  "license": "MIT",
+  "type": "module",
+  "repository": "github:RealAlexandreAI/pi-all-search",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "search",
+    "extension"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "dependencies": {
+    "@earendil-works/pi-ai": "^0.80.0",
+    "@earendil-works/pi-coding-agent": "^0.80.0",
+    "@earendil-works/pi-tui": "^0.80.0",
+    "typebox": "^0.34.0"
+  }
+}

package/src/config.ts

@@ -0,0 +1,24 @@
+import { PROVIDERS } from "./providers/index.js";
+
+export interface SearchConfig {
+  apiKeys: Record<string, string>;
+  routing?: {
+    finance?: string;
+    academic?: string;
+    general?: string;
+  };
+}
+
+export function loadConfig(): SearchConfig {
+  const env = process.env;
+  const apiKeys: Record<string, string> = {};
+  for (const meta of PROVIDERS) {
+    const key = env[meta.envVar];
+    if (key) apiKeys[meta.name] = key;
+  }
+  return { apiKeys };
+}
+
+export function resolveApiKey(name: string, envVar: string, config: SearchConfig): string | undefined {
+  return config.apiKeys[name] ?? process.env[envVar];
+}

package/src/providers/anysearch.ts

@@ -0,0 +1,28 @@
+import type { SearchProvider, SearchResult } from "./types.js";
+
+export const ANYSEARCH_META = { name: "anysearch", label: "AnySearch", envVar: "ANYSEARCH_API_KEY" };
+
+export class AnysearchProvider implements SearchProvider {
+  name = "anysearch";
+  constructor(private apiKey: string) {}
+
+  async search(query: string, maxResults: number): Promise<{ results: SearchResult[] }> {
+    const resp = await fetch("https://api.anysearch.dev/v1/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.apiKey}` },
+      body: JSON.stringify({ q: query, limit: maxResults }),
+    });
+    const data = await resp.json();
+    const results: SearchResult[] = (data.results ?? []).map((r: any) => ({
+      title: r.title ?? "",
+      url: r.url ?? "",
+      snippet: r.description ?? r.snippet ?? "",
+      score: r.score,
+    }));
+    return { results };
+  }
+
+  async verticalSearch(domain: string, subDomain: string, query: string, maxResults: number): Promise<{ results: SearchResult[] }> {
+    return this.search(query, maxResults);
+  }
+}

package/src/providers/brave.ts

@@ -0,0 +1,25 @@
+import type { SearchProvider, SearchResult } from "./types.js";
+
+export const BRAVE_META = { name: "brave", label: "Brave", envVar: "BRAVE_API_KEY" };
+
+export class BraveProvider implements SearchProvider {
+  name = "brave";
+  constructor(private apiKey: string) {}
+
+  async search(query: string, maxResults: number, signal?: AbortSignal): Promise<{ results: SearchResult[] }> {
+    const resp = await fetch(
+      `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${maxResults}`,
+      {
+        headers: { "X-Subscription-Token": this.apiKey, Accept: "application/json" },
+        signal,
+      }
+    );
+    const data = await resp.json();
+    const results: SearchResult[] = ((data.web?.results ?? []) as any[]).slice(0, maxResults).map((r) => ({
+      title: r.title ?? "",
+      url: r.url ?? "",
+      snippet: r.description ?? "",
+    }));
+    return { results };
+  }
+}

package/src/providers/exa.ts

@@ -0,0 +1,29 @@
+import type { SearchProvider, SearchResult } from "./types.js";
+
+export const EXA_META = { name: "exa", label: "Exa", envVar: "EXA_API_KEY" };
+
+export class ExaProvider implements SearchProvider {
+  name = "exa";
+  constructor(private apiKey: string) {}
+
+  async search(query: string, maxResults: number): Promise<{ results: SearchResult[] }> {
+    const resp = await fetch("https://api.exa.ai/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-api-key": this.apiKey },
+      body: JSON.stringify({
+        query,
+        numResults: maxResults,
+        type: "neural",
+        contents: { text: { maxCharacters: 300 } },
+      }),
+    });
+    const data = await resp.json();
+    const results: SearchResult[] = (data.results ?? []).map((r: any) => ({
+      title: r.title ?? "",
+      url: r.url ?? "",
+      snippet: r.text ?? "",
+      score: r.score,
+    }));
+    return { results };
+  }
+}

package/src/providers/firecrawl.ts

@@ -0,0 +1,23 @@
+import type { SearchProvider, SearchResult } from "./types.js";
+
+export const FIRECRAWL_META = { name: "firecrawl", label: "Firecrawl", envVar: "FIRECRAWL_API_KEY" };
+
+export class FirecrawlProvider implements SearchProvider {
+  name = "firecrawl";
+  constructor(private apiKey: string) {}
+
+  async search(query: string, maxResults: number): Promise<{ results: SearchResult[] }> {
+    const resp = await fetch("https://api.firecrawl.dev/v1/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.apiKey}` },
+      body: JSON.stringify({ query, limit: maxResults }),
+    });
+    const data = await resp.json();
+    const results: SearchResult[] = (data.data ?? []).map((r: any) => ({
+      title: r.title ?? "",
+      url: r.url ?? "",
+      snippet: r.description ?? "",
+    }));
+    return { results };
+  }
+}

package/src/providers/index.ts

@@ -0,0 +1,51 @@
+import { EXA_META, ExaProvider } from "./exa.js";
+import { TAVILY_META, TavilyProvider } from "./tavily.js";
+import { ANYSEARCH_META, AnysearchProvider } from "./anysearch.js";
+import { FIRECRAWL_META, FirecrawlProvider } from "./firecrawl.js";
+import { BRAVE_META, BraveProvider } from "./brave.js";
+import type { SearchProvider } from "./types.js";
+
+export interface ProviderMeta {
+  name: string;
+  label: string;
+  envVar: string;
+}
+
+export const PROVIDERS: readonly ProviderMeta[] = [
+  EXA_META,
+  TAVILY_META,
+  ANYSEARCH_META,
+  FIRECRAWL_META,
+  BRAVE_META,
+];
+
+export function createProvider(name: string, apiKey: string): SearchProvider {
+  switch (name) {
+    case "exa":
+      return new ExaProvider(apiKey);
+    case "tavily":
+      return new TavilyProvider(apiKey);
+    case "anysearch":
+      return new AnysearchProvider(apiKey);
+    case "firecrawl":
+      return new FirecrawlProvider(apiKey);
+    case "brave":
+      return new BraveProvider(apiKey);
+    default:
+      throw new Error(`Unknown provider: "${name}". Available: ${PROVIDERS.map((p) => p.name).join(", ")}`);
+  }
+}
+
+export function createAvailableProviders(apiKeys: Record<string, string | undefined>): Map<string, SearchProvider> {
+  const providers = new Map<string, SearchProvider>();
+  for (const meta of PROVIDERS) {
+    const key = apiKeys[meta.name];
+    if (!key) continue;
+    try {
+      providers.set(meta.name, createProvider(meta.name, key));
+    } catch {
+      // skip
+    }
+  }
+  return providers;
+}

package/src/providers/tavily.ts

@@ -0,0 +1,36 @@
+import type { SearchProvider, SearchResult } from "./types.js";
+
+export const TAVILY_META = { name: "tavily", label: "Tavily", envVar: "TAVILY_API_KEY" };
+
+export class TavilyProvider implements SearchProvider {
+  name = "tavily";
+  constructor(private apiKey: string) {}
+
+  async search(query: string, maxResults: number, signal?: AbortSignal): Promise<{ results: SearchResult[] }> {
+    const resp = await fetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ api_key: this.apiKey, query, max_results: maxResults, search_depth: "basic" }),
+      signal,
+    });
+    const data = await resp.json();
+    const results: SearchResult[] = (data.results ?? []).map((r: any) => ({
+      title: r.title ?? "",
+      url: r.url ?? "",
+      snippet: r.content ?? "",
+      score: r.score,
+    }));
+    return { results };
+  }
+
+  async research(query: string, signal?: AbortSignal): Promise<string> {
+    const resp = await fetch("https://api.tavily.com/search", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ api_key: this.apiKey, query, search_depth: "advanced", include_answer: true }),
+      signal,
+    });
+    const data = await resp.json();
+    return data.answer ?? "";
+  }
+}

package/src/providers/types.ts

@@ -0,0 +1,21 @@
+// ─── Search Provider Interface ────────────────────────────────────────
+export interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+  publishedAt?: string;
+  score?: number;
+}
+
+export interface SearchProvider {
+  name: string;
+  search(query: string, maxResults: number, signal?: AbortSignal): Promise<{ results: SearchResult[] }>;
+  research?(query: string, signal?: AbortSignal): Promise<string>;
+  verticalSearch?(domain: string, subDomain: string, query: string, maxResults: number, signal?: AbortSignal): Promise<{ results: SearchResult[] }>;
+}
+
+export interface ProviderMeta {
+  name: string;
+  label: string;
+  envVar: string;
+}

package/src/router.ts

@@ -0,0 +1,27 @@
+import type { SearchProvider } from "./providers/types.js";
+
+export type SearchIntent = "finance" | "academic" | "general";
+
+export function classifyIntent(query: string): SearchIntent {
+  const q = query.toLowerCase();
+  if (/\b(stock|price|ticker|forex|crypto|market|trade|earnings)\b/.test(q)) return "finance";
+  if (/\b(paper|research|journal|doi|arxiv|scholar|academic|study)\b/.test(q)) return "academic";
+  return "general";
+}
+
+const INTENT PROVIDERS: Record<SearchIntent, { primary: string; secondary: string[] }> = {
+  finance: { primary: "anysearch", secondary: ["brave", "exa"] },
+  academic: { primary: "exa", secondary: ["anysearch", "brave"] },
+  general: { primary: "tavily", secondary: ["brave", "exa", "anysearch"] },
+};
+
+export function routeIntent(
+  intent: SearchIntent,
+  providers: Map<string, SearchProvider>,
+  requestedProvider?: string
+): { primary: string; secondary: string[] } {
+  if (requestedProvider && providers.has(requestedProvider)) {
+    return { primary: requestedProvider, secondary: [...providers.keys()].filter((k) => k !== requestedProvider) };
+  }
+  return INTENT_PROVIDERS[intent];
+}

package/src/utils.ts

@@ -0,0 +1,34 @@
+import type { SearchResult } from "./providers/types.js";
+
+export function deduplicateResults(results: SearchResult[]): SearchResult[] {
+  const seen = new Set<string>();
+  return results.filter((r) => {
+    const key = r.url || r.title;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export class SafeMemoryCache<T> {
+  private cache = new Map<string, { value: T; expiry: number }>();
+  constructor(private ttlMs: number, private maxSize: number) {}
+
+  get(key: string): T | undefined {
+    const entry = this.cache.get(key);
+    if (!entry) return undefined;
+    if (Date.now() > entry.expiry) {
+      this.cache.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  set(key: string, value: T): void {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) this.cache.delete(firstKey);
+    }
+    this.cache.set(key, { value, expiry: Date.now() + this.ttlMs });
+  }
+}

package/src/web-search.ts

@@ -0,0 +1,267 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { loadConfig, resolveApiKey } from "./config.js";
+import { createAvailableProviders, PROVIDERS } from "./providers/index.js";
+import type { SearchProvider, SearchResult } from "./providers/types.js";
+import { classifyIntent, routeIntent, type SearchIntent } from "./router.js";
+import { deduplicateResults, SafeMemoryCache } from "./utils.js";
+
+export const searchCache = new SafeMemoryCache<any>(300000, 100);
+
+const MIN_RESULTS = 1;
+const MAX_RESULTS = 20;
+const DEFAULT_RESULTS = 5;
+
+function formatSearchResults(results: SearchResult[], provider: string): string {
+  let out = `*${results.length} results via ${provider}*\n\n`;
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    out += `${i + 1}. **${r.title}**\n`;
+    out += `   ${r.url}\n`;
+    const meta: string[] = [];
+    if (r.publishedAt) meta.push(r.publishedAt.slice(0, 10));
+    if (r.score !== undefined) meta.push(`score: ${r.score.toFixed(2)}`);
+    if (meta.length > 0) out += `   *${meta.join(" · ")}*\n`;
+    const snippet = r.snippet.slice(0, 300);
+    if (snippet.trim().length > 0) {
+      out += `   ${snippet}${r.snippet.length > 300 ? "..." : ""}\n`;
+    }
+    out += "\n";
+  }
+  return out.trimEnd();
+}
+
+function formatMultiQueryResults(
+  allQueries: Array<{ query: string; results: SearchResult[]; provider: string }>,
+): string {
+  let out = "";
+  for (const q of allQueries) {
+    out += `## "${q.query}"\n`;
+    out += formatSearchResults(q.results, q.provider);
+    out += "\n---\n\n";
+  }
+  return out.trimEnd();
+}
+
+async function executeSingleSearch(
+  providers: Map<string, SearchProvider>,
+  query: string,
+  maxResults: number,
+  requestedProvider?: string,
+  signal?: AbortSignal,
+): Promise<{ results: SearchResult[]; provider: string; intent: SearchIntent }> {
+  const intent = classifyIntent(query);
+  const route = routeIntent(intent, providers, requestedProvider);
+
+  let allResults: SearchResult[] = [];
+  let usedProvider = route.primary;
+  const errors: string[] = [];
+
+  const primary = providers.get(route.primary);
+  if (primary) {
+    try {
+      const resp = await primary.search(query, maxResults, signal);
+      allResults = resp.results;
+    } catch (err) {
+      errors.push(`${route.primary}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  if (allResults.length === 0) {
+    for (const name of route.secondary) {
+      const p = providers.get(name);
+      if (!p) continue;
+      try {
+        const resp = await p.search(query, maxResults, signal);
+        allResults = resp.results;
+        if (allResults.length > 0) {
+          usedProvider = name;
+          break;
+        }
+      } catch (err) {
+        errors.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+
+  if (allResults.length === 0 && errors.length > 0) {
+    throw new Error(`All providers failed for "${query}":\n${errors.join("\n")}`);
+  }
+
+  return { results: deduplicateResults(allResults), provider: usedProvider, intent };
+}
+
+async function executeSingleSearchWithTimeout(
+  providers: Map<string, SearchProvider>,
+  query: string,
+  maxResults: number,
+  requestedProvider?: string,
+  signal?: AbortSignal,
+  timeoutMs: number = 8000,
+): Promise<{ results: SearchResult[]; provider: string; intent: SearchIntent }> {
+  let timer: NodeJS.Timeout;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`Search timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+
+  return Promise.race([
+    executeSingleSearch(providers, query, maxResults, requestedProvider, signal).then((res) => {
+      clearTimeout(timer);
+      return res;
+    }),
+    timeoutPromise,
+  ]);
+}
+
+export function registerWebSearchTool(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "web_search",
+    label: "Web Search",
+    description:
+      "Search the web with automatic provider selection. For stocks/finance, uses Anysearch. For academic papers, uses Exa. For general web, uses Tavily. Falls back automatically if the primary provider fails. Use include_content with web_fetch for full page reading. Use queries (plural) for parallel multi-angle research.",
+    promptSnippet:
+      "Search the web with automatic or custom routing (set provider='exa' for papers, provider='anysearch' for finance, provider='tavily' for code, provider='brave' for general).",
+    get promptGuidelines() {
+      return [
+        "Use web_search for information beyond your training data — current events, recent docs, live data.",
+        "Set provider='anysearch' when searching for stock prices, tickers, forex, or CVE vulnerability hashes.",
+        "Set provider='exa' when searching for academic research papers, journals, or DOIs.",
+        "Set provider='tavily' for web pages, coding guides, library docs, and fast programming research.",
+        "Set provider='brave' for general web search with good coverage.",
+        "Set provider='firecrawl' for scraping-heavy sites or when others fail.",
+        "Set provider='auto' to let the fast local intent router decide automatically (default).",
+        "After answering, include a \"Sources:\" section with markdown hyperlinks: [Title](URL).",
+        "Use web_fetch after web_search to read full page content — web_search returns snippets only.",
+        "Use {queries:[...]} with 2-4 varied angles for broader coverage.",
+      ];
+    },
+    parameters: Type.Object({
+      query: Type.Optional(
+        Type.String({ description: "Single search query. Use 'queries' for multi-angle research." }),
+      ),
+      queries: Type.Optional(
+        Type.Array(Type.String(), {
+          description:
+            "Multiple queries searched in parallel, each routed independently. Prefer 2-4 varied angles.",
+        }),
+      ),
+      provider: Type.Optional(
+        StringEnum(["auto", "exa", "tavily", "anysearch", "firecrawl", "brave"], {
+          description:
+            "Directly override the search provider. 'auto' uses local intent routing (default).",
+          default: "auto",
+        }),
+      ),
+      max_results: Type.Optional(
+        Type.Number({
+          description: `Results per query (${MIN_RESULTS}-${MAX_RESULTS}, default ${DEFAULT_RESULTS}).`,
+          minimum: MIN_RESULTS,
+          maximum: MAX_RESULTS,
+          default: DEFAULT_RESULTS,
+        }),
+      ),
+      freshness: Type.Optional(StringEnum(["day", "week", "month", "year"], { description: "Filter by recency." })),
+    }),
+
+    async execute(_toolCallId, params, signal, onUpdate) {
+      const maxResults = Math.min(Math.max(params.max_results ?? DEFAULT_RESULTS, MIN_RESULTS), MAX_RESULTS);
+
+      const queryList = (Array.isArray(params.queries) ? params.queries : [])
+        .map((q) => (typeof q === "string" ? q.trim() : ""))
+        .filter(Boolean);
+      if (queryList.length === 0 && typeof params.query === "string" && params.query.trim()) {
+        queryList.push(params.query.trim());
+      }
+
+      if (queryList.length === 0) {
+        return {
+          content: [{ type: "text", text: "No query provided. Use 'query' or 'queries' parameter." }],
+          details: { error: "No query" },
+        };
+      }
+
+      const requestedProvider = params.provider as string | undefined;
+      const cacheKey = JSON.stringify({ queries: queryList, maxResults, provider: requestedProvider });
+      const cached = searchCache.get(cacheKey);
+      if (cached) {
+        onUpdate?.({ content: [{ type: "text", text: "Searching... (Cache Hit!)" }], details: { phase: "searching", cacheHit: true } });
+        return cached;
+      }
+
+      const config = loadConfig();
+      const apiKeys: Record<string, string | undefined> = {};
+      for (const meta of PROVIDERS) {
+        apiKeys[meta.name] = resolveApiKey(meta.name, meta.envVar, config);
+      }
+      const providers = createAvailableProviders(apiKeys);
+
+      if (providers.size === 0) {
+        const envVars = PROVIDERS.map((p) => p.envVar).join(", ");
+        return {
+          content: [{ type: "text", text: `No search providers available. Set ${envVars}.` }],
+          details: { error: "No providers" },
+        };
+      }
+
+      let responsePayload: any;
+
+      if (queryList.length > 1) {
+        onUpdate?.({ content: [{ type: "text", text: `Searching ${queryList.length} queries in parallel...` }], details: { phase: "searching", queryCount: queryList.length } });
+        const results = await Promise.all(
+          queryList.map(async (q) => {
+            try {
+              const r = await executeSingleSearchWithTimeout(providers, q, maxResults, requestedProvider, signal);
+              return { query: q, results: r.results, provider: r.provider, intent: r.intent };
+            } catch (err) {
+              return { query: q, results: [] as SearchResult[], provider: "error", intent: "general" as SearchIntent, error: err instanceof Error ? err.message : String(err) };
+            }
+          }),
+        );
+        const providers_used = [...new Set(results.map((r) => r.provider))];
+        const totalResults = results.reduce((sum, r) => sum + r.results.length, 0);
+        const errors = results.filter((r) => "error" in r && r.error);
+        responsePayload = {
+          content: [{ type: "text", text: formatMultiQueryResults(results) }],
+          details: { queryCount: queryList.length, totalResults, providers: providers_used, errors: errors.length > 0 ? errors.map((e) => (e as any).error) : undefined },
+        };
+      } else {
+        const query = queryList[0];
+        onUpdate?.({ content: [{ type: "text", text: `Searching: "${query}"...` }], details: { phase: "searching" } });
+        const { results, provider, intent } = await executeSingleSearchWithTimeout(providers, query, maxResults, requestedProvider, signal);
+        const text = formatSearchResults(results, provider);
+        responsePayload = { content: [{ type: "text", text }], details: { query, intent, provider, resultCount: results.length } };
+      }
+
+      searchCache.set(cacheKey, responsePayload);
+      return responsePayload;
+    },
+
+    renderCall(args, theme) {
+      const ql = Array.isArray(args.queries) ? args.queries.filter((q: unknown) => typeof q === "string") : [];
+      if (ql.length > 1) {
+        return new Text(theme.fg("toolTitle", theme.bold("Search ")) + theme.fg("accent", `${ql.length} queries`), 0, 0);
+      }
+      const q = (args.query as string) || ql[0] || "";
+      const display = q.length > 60 ? `${q.slice(0, 57)}...` : q;
+      return new Text(theme.fg("toolTitle", theme.bold("Search ")) + theme.fg("accent", `"${display}"`), 0, 0);
+    },
+
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial) {
+        const d = result.details as { phase?: string; queryCount?: number } | undefined;
+        if (d?.queryCount) {
+          return new Text(theme.fg("warning", `Searching ${d.queryCount} queries...`), 0, 0);
+        }
+        return new Text(theme.fg("warning", "Searching..."), 0, 0);
+      }
+      const d = result.details as { resultCount?: number; totalResults?: number; provider?: string; providers?: string[]; error?: string } | undefined;
+      if (d?.error) return new Text(theme.fg("error", d.error), 0, 0);
+      const count = d?.totalResults ?? d?.resultCount ?? 0;
+      const provider = d?.providers?.join("+") ?? d?.provider ?? "?";
+      const label = `✓ ${count} results via ${provider}`;
+      return new Text(theme.fg("success", label), 0, 0);
+    },
+  });
+}