@alasano/pi-exa 0.0.1

package/extensions/tools/web-agent.ts

@@ -0,0 +1,328 @@
+import { defineTool } from '@earendil-works/pi-coding-agent';
+import type { AgentToolUpdateCallback } from '@earendil-works/pi-coding-agent';
+import type { Static } from '@sinclair/typebox';
+import {
+  createAgentRun,
+  getAgentRun,
+  getRunIdFromAgentEvent,
+  isTerminalAgentStatus,
+  pollAgentRunUntilFinished,
+  streamAgentRunEvents,
+  type ExaAgentCreateRequest,
+} from '../agent';
+import type { AgentRunTracker } from '../agent-tracker';
+import { countAgentSources, formatAgentRunResponse } from '../format';
+import { truncateToolOutput } from '../output';
+import {
+  buildAgentRunPreview,
+  metadataFromArgs,
+  renderExaCall,
+  renderExaResult,
+  sendProgress,
+} from '../render';
+import { WebAgentParamsSchema } from '../schemas';
+import type { ExaAgentEvent, ExaAgentRun, ExaToolDetails, PreviewDetails } from '../types';
+import { compactObject } from '../util';
+import { withExaApiKey, errorResult } from './helpers';
+
+type WebAgentParams = Static<typeof WebAgentParamsSchema>;
+
+const DEFAULT_AGENT_POLL_INTERVAL_MS = 4000;
+const DEFAULT_AGENT_TIMEOUT_MS = 10 * 60 * 1000;
+
+export interface WebAgentRequest extends ExaAgentCreateRequest {}
+
+type WebAgentDetails =
+  | (Partial<ExaToolDetails<ExaAgentRun, WebAgentRequest>> & {
+      mode: 'wait' | 'background';
+      monitor?: 'stream' | 'poll';
+      timedOut?: boolean;
+      events?: string[];
+    })
+  | undefined;
+
+function createTimeoutSignal(parentSignal: AbortSignal | undefined, timeoutMs: number) {
+  const controller = new AbortController();
+  let timedOut = false;
+
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error(`Timed out after ${timeoutMs}ms.`));
+  }, timeoutMs);
+
+  const abortFromParent = () => {
+    controller.abort(parentSignal?.reason ?? new Error('Operation aborted.'));
+  };
+  parentSignal?.addEventListener('abort', abortFromParent, { once: true });
+
+  return {
+    signal: controller.signal,
+    isTimedOut: () => timedOut,
+    dispose: () => {
+      clearTimeout(timeout);
+      parentSignal?.removeEventListener('abort', abortFromParent);
+    },
+  };
+}
+
+function agentEventProgress(event: ExaAgentEvent): string {
+  const runId = getRunIdFromAgentEvent(event);
+  const status = typeof event.data.status === 'string' ? event.data.status : undefined;
+  return [
+    `Exa Agent event: ${event.event}`,
+    runId ? `run=${runId}` : undefined,
+    status ? `status=${status}` : undefined,
+  ]
+    .filter(Boolean)
+    .join(' | ');
+}
+
+function sendAgentTimelineUpdate(
+  onUpdate: AgentToolUpdateCallback<WebAgentDetails> | undefined,
+  events: string[],
+  summary = 'running',
+) {
+  const preview: PreviewDetails = {
+    kind: 'agent',
+    summary,
+    lines: events.slice(-6),
+    expandedLines: events,
+  };
+
+  onUpdate?.({
+    content: [{ type: 'text', text: events[events.length - 1] || 'Running Exa Agent...' }],
+    details: {
+      endpoint: '/agent/runs',
+      mode: 'wait',
+      monitor: 'stream',
+      events,
+      preview,
+    },
+  });
+}
+
+function formatElapsedTime(ms: number): string {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return remainingSeconds === 0 ? `${minutes}m` : `${minutes}m ${remainingSeconds}s`;
+}
+
+function sendAgentPollingUpdate(
+  onUpdate: AgentToolUpdateCallback<WebAgentDetails> | undefined,
+  run: ExaAgentRun,
+  startedAt: number,
+) {
+  const elapsed = formatElapsedTime(Date.now() - startedAt);
+  const lines = [`Run ID: ${run.id}`, `Status: ${run.status}`];
+  const preview: PreviewDetails = {
+    kind: 'agent',
+    summary: `${run.status} | elapsed ${elapsed}`,
+    lines,
+    expandedLines: lines,
+  };
+
+  onUpdate?.({
+    content: [{ type: 'text', text: `Exa Agent run ${run.id} is ${run.status}; polling...` }],
+    details: {
+      endpoint: '/agent/runs',
+      response: run,
+      requestId: run.id,
+      mode: 'wait',
+      monitor: 'poll',
+      preview,
+    },
+  });
+}
+
+function remainingTimeout(startedAt: number, timeoutMs: number): number {
+  return Math.max(1000, timeoutMs - (Date.now() - startedAt));
+}
+
+export function buildWebAgentRequest(params: WebAgentParams): WebAgentRequest {
+  return compactObject({
+    query: params.query,
+    systemPrompt: params.systemPrompt,
+    input: params.input,
+    outputSchema: params.outputSchema,
+    effort: params.effort,
+    previousRunId: params.previousRunId,
+    metadata: params.metadata,
+  }) as WebAgentRequest;
+}
+
+async function waitWithPolling(
+  apiKey: string,
+  request: WebAgentRequest,
+  params: WebAgentParams,
+  signal: AbortSignal | undefined,
+  onUpdate: AgentToolUpdateCallback<WebAgentDetails> | undefined,
+): Promise<{ run: ExaAgentRun; timedOut: boolean }> {
+  const pollIntervalMs = params.pollIntervalMs ?? DEFAULT_AGENT_POLL_INTERVAL_MS;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS;
+  const startedAt = Date.now();
+
+  sendProgress(onUpdate, 'Starting Exa Agent run...');
+  const initialRun = await createAgentRun(apiKey, request, signal);
+  sendAgentPollingUpdate(onUpdate, initialRun, startedAt);
+
+  if (isTerminalAgentStatus(initialRun.status)) return { run: initialRun, timedOut: false };
+
+  return pollAgentRunUntilFinished(apiKey, initialRun.id, {
+    pollIntervalMs,
+    timeoutMs,
+    signal,
+    onPoll: (run) => {
+      sendAgentPollingUpdate(onUpdate, run, startedAt);
+    },
+  });
+}
+
+async function waitWithStreaming(
+  apiKey: string,
+  request: WebAgentRequest,
+  params: WebAgentParams,
+  signal: AbortSignal | undefined,
+  onUpdate: AgentToolUpdateCallback<WebAgentDetails> | undefined,
+): Promise<{ run: ExaAgentRun; timedOut: boolean }> {
+  const pollIntervalMs = params.pollIntervalMs ?? DEFAULT_AGENT_POLL_INTERVAL_MS;
+  const timeoutMs = params.timeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS;
+  const startedAt = Date.now();
+  const timeoutSignal = createTimeoutSignal(signal, timeoutMs);
+  let runId: string | undefined;
+  let terminalFromStream = false;
+  const events: string[] = [];
+
+  try {
+    sendProgress(onUpdate, 'Starting Exa Agent run with streaming events...');
+    for await (const event of streamAgentRunEvents(apiKey, request, timeoutSignal.signal)) {
+      runId = getRunIdFromAgentEvent(event) ?? runId;
+      const status = typeof event.data.status === 'string' ? event.data.status : undefined;
+      terminalFromStream = terminalFromStream || isTerminalAgentStatus(status);
+      const line = agentEventProgress(event);
+      events.push(line);
+      sendAgentTimelineUpdate(onUpdate, events, status || 'running');
+    }
+  } catch (error) {
+    if (!runId || (!timeoutSignal.isTimedOut() && signal?.aborted)) throw error;
+    if (timeoutSignal.isTimedOut()) {
+      const run = await getAgentRun(apiKey, runId, signal);
+      return { run, timedOut: true };
+    }
+
+    sendProgress(onUpdate, `Exa Agent stream ended; polling run ${runId}...`);
+    return pollAgentRunUntilFinished(apiKey, runId, {
+      pollIntervalMs,
+      timeoutMs: remainingTimeout(startedAt, timeoutMs),
+      signal,
+    });
+  } finally {
+    timeoutSignal.dispose();
+  }
+
+  if (!runId) throw new Error('Exa Agent stream ended before a run ID was returned.');
+
+  if (terminalFromStream) {
+    return { run: await getAgentRun(apiKey, runId, signal), timedOut: false };
+  }
+
+  return pollAgentRunUntilFinished(apiKey, runId, {
+    pollIntervalMs,
+    timeoutMs: remainingTimeout(startedAt, timeoutMs),
+    signal,
+  });
+}
+
+export function createWebAgentTool(tracker: AgentRunTracker) {
+  return defineTool<typeof WebAgentParamsSchema, WebAgentDetails>({
+    name: 'web_agent_exa',
+    label: 'Exa Agent',
+    description:
+      'Create an Exa Agent run for deep web research, list-building, enrichment, or structured multi-hop workflows. Supports foreground wait and background tracking.',
+    promptSnippet: 'Run an Exa Agent research/list-building/enrichment workflow',
+    promptGuidelines: [
+      'Use web_agent_exa when the task needs multi-hop research, list building, row enrichment, or structured fields across many sources.',
+      'Prefer normal search/answer/fetch tools for simple lookup. Use Agent only when it is clearly the better tool or recommend it to the user when the task fits.',
+      'For structured output, provide outputSchema and bound arrays with maxItems so scope and contact-enrichment cost stay predictable.',
+      'Use mode=background for long-running or expensive Agent work when the user does not need the result in the current turn.',
+      'Completed foreground wait runs return the full Agent result payload, including structured output and grounding.',
+      'After starting a background run, do not poll with web_agent_get_exa or web_agent_events_exa unless the user explicitly asks; pi-exa tracks the run and sends a compact follow-up when it completes.',
+      'Treat background follow-ups as completion notices. Call web_agent_get_exa before answering with detailed findings from a background run.',
+    ],
+    parameters: WebAgentParamsSchema,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const request = buildWebAgentRequest(params);
+      const mode = params.mode ?? 'wait';
+      const monitor = params.monitor ?? 'stream';
+
+      try {
+        return await withExaApiKey(ctx, async (apiKey) => {
+          let run: ExaAgentRun;
+          let timedOut = false;
+
+          if (mode === 'background') {
+            sendProgress(onUpdate, 'Starting Exa Agent run in background...');
+            run = await createAgentRun(apiKey, request, signal);
+            await tracker.track(run, { pollIntervalMs: params.pollIntervalMs }, ctx);
+          } else if (monitor === 'poll') {
+            const result = await waitWithPolling(apiKey, request, params, signal, onUpdate);
+            run = result.run;
+            timedOut = result.timedOut;
+          } else {
+            const result = await waitWithStreaming(apiKey, request, params, signal, onUpdate);
+            run = result.run;
+            timedOut = result.timedOut;
+          }
+
+          if (timedOut) await tracker.track(run, { pollIntervalMs: params.pollIntervalMs }, ctx);
+
+          const output = await truncateToolOutput(
+            formatAgentRunResponse(run, { timedOut, background: mode === 'background' }),
+            'web-agent-exa',
+            'Use web_agent_get_exa for the run ID, simplify outputSchema, reduce maxItems, or use mode=background. ',
+            { maxLines: Number.MAX_SAFE_INTEGER, maxBytes: Number.MAX_SAFE_INTEGER },
+          );
+
+          return {
+            content: [{ type: 'text', text: output.text }],
+            details: {
+              endpoint: '/agent/runs',
+              request,
+              response: run,
+              requestId: run.id,
+              count: countAgentSources(run.output?.grounding),
+              costDollars: run.costDollars,
+              preview: buildAgentRunPreview(run, output, {
+                timedOut,
+                background: mode === 'background',
+              }),
+              truncated: output.truncation.truncated,
+              truncation: output.truncation,
+              fullOutputPath: output.fullOutputPath,
+              mode,
+              monitor: mode === 'wait' ? monitor : undefined,
+              timedOut,
+            },
+            isError: run.status === 'failed',
+          };
+        });
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+    renderCall(args, theme) {
+      const metadataArgs = args.mode === 'background' ? { ...args, monitor: undefined } : args;
+
+      return renderExaCall(
+        'web_agent_exa',
+        `"${args.query}"`,
+        theme,
+        metadataFromArgs(metadataArgs, ['mode', 'monitor', 'effort', 'previousRunId']),
+      );
+    },
+    renderResult(result, options, theme) {
+      return renderExaResult(result, options, theme, 'Running Exa Agent...');
+    },
+  });
+}

package/extensions/tools/web-answer.ts

@@ -0,0 +1,92 @@
+import { defineTool } from '@earendil-works/pi-coding-agent';
+import type { Static } from '@sinclair/typebox';
+import { exaPost } from '../client';
+import { formatAnswerResponse } from '../format';
+import { truncateToolOutput } from '../output';
+import {
+  buildAnswerPreview,
+  metadataFromArgs,
+  renderExaCall,
+  renderExaResult,
+  sendProgress,
+} from '../render';
+import { WebAnswerParamsSchema } from '../schemas';
+import type { ExaAnswerResponse, ExaToolDetails, JsonObject } from '../types';
+import { compactObject } from '../util';
+import { withExaApiKey, errorResult } from './helpers';
+
+type WebAnswerParams = Static<typeof WebAnswerParamsSchema>;
+
+export interface WebAnswerRequest {
+  query: string;
+  text?: boolean;
+  outputSchema?: JsonObject;
+}
+
+export function buildWebAnswerRequest(params: WebAnswerParams): WebAnswerRequest {
+  return compactObject({
+    query: params.query,
+    text: params.text,
+    outputSchema: params.outputSchema,
+  }) as WebAnswerRequest;
+}
+
+export function createWebAnswerTool() {
+  return defineTool<
+    typeof WebAnswerParamsSchema,
+    ExaToolDetails<ExaAnswerResponse, WebAnswerRequest> | undefined
+  >({
+    name: 'web_answer_exa',
+    label: 'Exa Web Answer',
+    description:
+      'Ask Exa Answer for a direct sourced answer. Use when a generated answer with citations is better than a search result list.',
+    promptSnippet: 'Ask Exa for a sourced answer',
+    promptGuidelines: [
+      'Use web_answer_exa when the user wants a direct sourced answer; use web_search_exa when the agent needs to inspect or compare sources itself.',
+      'Do not set web_answer_exa text=true unless citation page text is necessary.',
+    ],
+    parameters: WebAnswerParamsSchema,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const request = buildWebAnswerRequest(params);
+      try {
+        return await withExaApiKey(ctx, async (apiKey) => {
+          sendProgress(onUpdate, 'Getting grounded answer from Exa...');
+          const response = await exaPost<ExaAnswerResponse>(apiKey, '/answer', request, signal);
+          const output = await truncateToolOutput(
+            formatAnswerResponse(response),
+            'web-answer-exa',
+            'Set text=false or ask a narrower question. ',
+          );
+          return {
+            content: [{ type: 'text', text: output.text }],
+            details: {
+              endpoint: '/answer',
+              request,
+              response,
+              requestId: response.requestId,
+              count: response.citations?.length ?? 0,
+              costDollars: response.costDollars,
+              preview: buildAnswerPreview(response, output),
+              truncated: output.truncation.truncated,
+              truncation: output.truncation,
+              fullOutputPath: output.fullOutputPath,
+            },
+          };
+        });
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+    renderCall(args, theme) {
+      return renderExaCall(
+        'web_answer_exa',
+        `"${args.query}"`,
+        theme,
+        metadataFromArgs(args, ['text']),
+      );
+    },
+    renderResult(result, options, theme) {
+      return renderExaResult(result, options, theme, 'Getting grounded answer from Exa...');
+    },
+  });
+}

package/extensions/tools/web-fetch.ts

@@ -0,0 +1,94 @@
+import { defineTool } from '@earendil-works/pi-coding-agent';
+import type { Static } from '@sinclair/typebox';
+import { exaPost } from '../client';
+import { formatContentsResponse, hasContentsErrors } from '../format';
+import { truncateToolOutput } from '../output';
+import {
+  buildContentsPreview,
+  metadataFromArgs,
+  renderExaCall,
+  renderExaResult,
+  sendProgress,
+} from '../render';
+import { WebFetchParamsSchema } from '../schemas';
+import type { ExaContentsResponse, ExaToolDetails } from '../types';
+import { withExaApiKey, errorResult } from './helpers';
+
+type WebFetchParams = Static<typeof WebFetchParamsSchema>;
+
+export interface WebFetchRequest {
+  urls: string[];
+  text: {
+    maxCharacters: number;
+  };
+}
+
+export function buildWebFetchRequest(params: WebFetchParams): WebFetchRequest {
+  return {
+    urls: params.urls,
+    text: {
+      maxCharacters: params.maxCharacters ?? 3000,
+    },
+  };
+}
+
+export function createWebFetchTool() {
+  return defineTool<
+    typeof WebFetchParamsSchema,
+    ExaToolDetails<ExaContentsResponse, WebFetchRequest> | undefined
+  >({
+    name: 'web_fetch_exa',
+    label: 'Exa Web Fetch',
+    description:
+      'Read clean markdown content from known URLs with Exa. Use after search when selected URLs need fuller content.',
+    promptSnippet: 'Fetch clean markdown from known URLs with Exa',
+    promptGuidelines: [
+      'Use web_fetch_exa only after selecting promising URLs; avoid fetching every search result.',
+      'Keep web_fetch_exa maxCharacters as small as the task allows.',
+    ],
+    parameters: WebFetchParamsSchema,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const request = buildWebFetchRequest(params);
+      try {
+        return await withExaApiKey(ctx, async (apiKey) => {
+          sendProgress(onUpdate, 'Fetching contents from Exa...');
+          const response = await exaPost<ExaContentsResponse>(apiKey, '/contents', request, signal);
+          const output = await truncateToolOutput(
+            formatContentsResponse(response),
+            'web-fetch-exa',
+            'Fetch fewer URLs or reduce maxCharacters. ',
+          );
+          return {
+            content: [{ type: 'text', text: output.text }],
+            details: {
+              endpoint: '/contents',
+              request,
+              response,
+              requestId: response.requestId,
+              count: response.results?.length ?? 0,
+              costDollars: response.costDollars,
+              preview: buildContentsPreview(response, params.urls.length, output),
+              truncated: output.truncation.truncated,
+              truncation: output.truncation,
+              fullOutputPath: output.fullOutputPath,
+            },
+            isError: hasContentsErrors(response) && !response.results?.length,
+          };
+        });
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+    renderCall(args, theme) {
+      return renderExaCall(
+        'web_fetch_exa',
+        `${args.urls.length} URL(s)`,
+        theme,
+        metadataFromArgs(args, ['maxCharacters']),
+      );
+    },
+    renderResult(result, options, theme) {
+      return renderExaResult(result, options, theme, 'Fetching contents from Exa...');
+    },
+  });
+}

package/extensions/tools/web-search-advanced.ts

@@ -0,0 +1,164 @@
+import { defineTool } from '@earendil-works/pi-coding-agent';
+import type { Static } from '@sinclair/typebox';
+import { exaPost } from '../client';
+import { formatSearchResponse } from '../format';
+import { truncateToolOutput } from '../output';
+import {
+  buildSearchPreview,
+  metadataFromArgs,
+  renderExaCall,
+  renderExaResult,
+  sendProgress,
+} from '../render';
+import { WebSearchAdvancedParamsSchema } from '../schemas';
+import type { ExaSearchResponse, ExaToolDetails, JsonObject, SearchType } from '../types';
+import { compactObject } from '../util';
+import { withExaApiKey, errorResult } from './helpers';
+
+type WebSearchAdvancedParams = Static<typeof WebSearchAdvancedParamsSchema>;
+
+type HighlightsRequest = true | { maxCharacters?: number; query?: string };
+
+export interface WebSearchAdvancedRequest {
+  query: string;
+  type: SearchType;
+  numResults: number;
+  contents: JsonObject;
+  category?: string;
+  includeDomains?: string[];
+  excludeDomains?: string[];
+  startPublishedDate?: string;
+  endPublishedDate?: string;
+  startCrawlDate?: string;
+  endCrawlDate?: string;
+  includeText?: string[];
+  excludeText?: string[];
+  userLocation?: string;
+  moderation?: boolean;
+  additionalQueries?: string[];
+}
+
+function buildHighlights(params: WebSearchAdvancedParams): HighlightsRequest | undefined {
+  if (!params.enableHighlights) return undefined;
+
+  if (params.highlightsMaxCharacters !== undefined || params.highlightsQuery !== undefined) {
+    return compactObject({
+      maxCharacters: params.highlightsMaxCharacters,
+      query: params.highlightsQuery,
+    });
+  }
+
+  return true;
+}
+
+function buildContents(params: WebSearchAdvancedParams): JsonObject {
+  return compactObject({
+    text:
+      params.textMaxCharacters !== undefined ? { maxCharacters: params.textMaxCharacters } : true,
+    context:
+      params.contextMaxCharacters !== undefined
+        ? { maxCharacters: params.contextMaxCharacters }
+        : undefined,
+    summary: params.enableSummary
+      ? params.summaryQuery
+        ? { query: params.summaryQuery }
+        : true
+      : undefined,
+    highlights: buildHighlights(params),
+    maxAgeHours: params.maxAgeHours,
+    livecrawlTimeout: params.livecrawlTimeout,
+    subpages: params.subpages,
+    subpageTarget: params.subpageTarget,
+  });
+}
+
+export function buildWebSearchAdvancedRequest(
+  params: WebSearchAdvancedParams,
+): WebSearchAdvancedRequest {
+  return compactObject({
+    query: params.query,
+    type: params.type ?? 'auto',
+    numResults: params.numResults ?? 10,
+    contents: buildContents(params),
+    category: params.category,
+    includeDomains: params.includeDomains,
+    excludeDomains: params.excludeDomains,
+    startPublishedDate: params.startPublishedDate,
+    endPublishedDate: params.endPublishedDate,
+    startCrawlDate: params.startCrawlDate,
+    endCrawlDate: params.endCrawlDate,
+    includeText: params.includeText,
+    excludeText: params.excludeText,
+    userLocation: params.userLocation,
+    moderation: params.moderation,
+    additionalQueries: params.additionalQueries,
+  }) as WebSearchAdvancedRequest;
+}
+
+export function createWebSearchAdvancedTool() {
+  return defineTool<
+    typeof WebSearchAdvancedParamsSchema,
+    ExaToolDetails<ExaSearchResponse, WebSearchAdvancedRequest> | undefined
+  >({
+    name: 'web_search_advanced_exa',
+    label: 'Exa Advanced Search',
+    description:
+      'Advanced Exa web search with filters, domain restrictions, date ranges, highlights, summaries, freshness, and subpage crawling.',
+    promptSnippet: 'Search Exa with filters, dates, domains, and content controls',
+    promptGuidelines: [
+      'Use web_search_advanced_exa when the search requires filters, dates, domains, categories, summaries, freshness, or subpages.',
+      'Use textMaxCharacters when the task needs text but must keep each result bounded.',
+    ],
+    parameters: WebSearchAdvancedParamsSchema,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const request = buildWebSearchAdvancedRequest(params);
+      try {
+        return await withExaApiKey(ctx, async (apiKey) => {
+          sendProgress(onUpdate, 'Searching Exa with advanced filters...');
+          const response = await exaPost<ExaSearchResponse>(apiKey, '/search', request, signal);
+          const output = await truncateToolOutput(
+            formatSearchResponse(response),
+            'web-search-advanced-exa',
+            'Reduce numResults, set textMaxCharacters, disable optional summaries/highlights, or narrow filters. ',
+          );
+          return {
+            content: [{ type: 'text', text: output.text }],
+            details: {
+              endpoint: '/search',
+              request,
+              response,
+              requestId: response.requestId,
+              count: response.results?.length ?? 0,
+              costDollars: response.costDollars,
+              preview: buildSearchPreview(response, output),
+              truncated: output.truncation.truncated,
+              truncation: output.truncation,
+              fullOutputPath: output.fullOutputPath,
+            },
+          };
+        });
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+    renderCall(args, theme) {
+      return renderExaCall(
+        'web_search_advanced_exa',
+        `"${args.query}"`,
+        theme,
+        metadataFromArgs(args, [
+          'type',
+          'numResults',
+          'category',
+          'textMaxCharacters',
+          'contextMaxCharacters',
+          'enableHighlights',
+          'enableSummary',
+        ]),
+      );
+    },
+    renderResult(result, options, theme) {
+      return renderExaResult(result, options, theme, 'Searching Exa with advanced filters...');
+    },
+  });
+}