@oh-my-pi/exa 1.3.37 → 1.3.372

package/README.md

@@ -59,10 +59,10 @@ Get your API key from: https://dashboard.exa.ai/api-keys
 
 | Tool                      | Description                                          |
 | ------------------------- | ---------------------------------------------------- |
-| `web_search_general`      | Real-time web searches with content extraction       |
+| `web_search`              | Real-time web searches with content extraction       |
 | `web_search_deep`         | Natural language web search with synthesized results |
 | `web_search_code_context` | Search code snippets, docs, and examples             |
-| `web_search_crawl_url`    | Extract content from specific URLs                   |
+| `web_search_crawl`        | Extract content from specific URLs                   |
 
 ### linkedin
 
@@ -72,16 +72,16 @@ Get your API key from: https://dashboard.exa.ai/api-keys
 
 ### company
 
-| Tool                          | Description                    |
-| ----------------------------- | ------------------------------ |
-| `web_search_company_research` | Comprehensive company research |
+| Tool                 | Description                    |
+| -------------------- | ------------------------------ |
+| `web_search_company` | Comprehensive company research |
 
 ### researcher
 
 | Tool                          | Description                                  |
 | ----------------------------- | -------------------------------------------- |
 | `web_search_researcher_start` | Start comprehensive AI-powered research task |
-| `web_search_researcher_check` | Check research task status and get results   |
+| `web_search_researcher_poll`  | Check research task status and get results   |
 
 ### websets
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oh-my-pi/exa",
-  "version": "1.3.37",
+  "version": "1.3.372",
   "description": "Exa AI web search and websets tools for pi",
   "keywords": [
     "omp-plugin",

package/tools/company.ts

@@ -2,45 +2,31 @@
  * Exa Company Research Tool
  *
  * Tools:
- *   - web_search_company_research: Comprehensive company research
+ *   - web_search_company: Comprehensive company research
  */
 
-import type { TSchema } from "@sinclair/typebox";
-import type {
-  CustomAgentTool,
-  CustomToolFactory,
-  ToolAPI,
-} from "@mariozechner/pi-coding-agent";
-import {
-  callExaTool,
-  createToolWrapper,
-  fetchExaTools,
-  findApiKey,
-} from "./shared";
+import type { CustomAgentTool, CustomToolFactory, ToolAPI } from '@mariozechner/pi-coding-agent'
+import type { TSchema } from '@sinclair/typebox'
+import { callExaTool, createToolWrapper, fetchExaTools, findApiKey } from './shared'
 
 // MCP tool names for this feature
-const TOOL_NAMES = ["company_research_exa"];
+const TOOL_NAMES = ['company_research_exa']
 
 // Tool name mapping: MCP name -> exposed name
 const NAME_MAP: Record<string, string> = {
-  company_research_exa: "web_search_company_research",
-};
+   company_research_exa: 'web_search_company',
+}
 
-const factory: CustomToolFactory = async (
-  _toolApi: ToolAPI,
-): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
-  const apiKey = findApiKey();
-  if (!apiKey) return null;
+const factory: CustomToolFactory = async (_toolApi: ToolAPI): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
+   const apiKey = findApiKey()
+   if (!apiKey) return null
 
-  const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES);
-  if (mcpTools.length === 0) return null;
+   const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES)
+   if (mcpTools.length === 0) return null
 
-  const callFn = (toolName: string, args: Record<string, unknown>) =>
-    callExaTool(apiKey, TOOL_NAMES, toolName, args);
+   const callFn = (toolName: string, args: Record<string, unknown>) => callExaTool(apiKey, TOOL_NAMES, toolName, args)
 
-  return mcpTools.map((tool) =>
-    createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn),
-  );
-};
+   return mcpTools.map(tool => createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn))
+}
 
-export default factory;
+export default factory

package/tools/index.ts

@@ -12,64 +12,55 @@
  *   - websets: Entity collection management
  */
 
-import type { TSchema } from "@sinclair/typebox";
-import type {
-  CustomAgentTool,
-  CustomToolFactory,
-  ToolAPI,
-} from "@mariozechner/pi-coding-agent";
-import runtime from "./runtime.json";
+import type { CustomAgentTool, CustomToolFactory, ToolAPI } from '@mariozechner/pi-coding-agent'
+import type { TSchema } from '@sinclair/typebox'
+import runtime from './runtime.json'
 
 // Map feature names to their module imports
-const FEATURE_LOADERS: Record<
-  string,
-  () => Promise<{ default: CustomToolFactory }>
-> = {
-  search: () => import("./search"),
-  linkedin: () => import("./linkedin"),
-  company: () => import("./company"),
-  researcher: () => import("./researcher"),
-  websets: () => import("./websets"),
-};
+const FEATURE_LOADERS: Record<string, () => Promise<{ default: CustomToolFactory }>> = {
+   search: () => import('./search'),
+   linkedin: () => import('./linkedin'),
+   company: () => import('./company'),
+   researcher: () => import('./researcher'),
+   websets: () => import('./websets'),
+}
 
 /**
  * Factory function that loads enabled features from runtime.json
  */
-const factory: CustomToolFactory = async (
-  toolApi: ToolAPI,
-): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
-  const allTools: CustomAgentTool<TSchema, unknown>[] = [];
-  const enabledFeatures = runtime.features ?? [];
+const factory: CustomToolFactory = async (toolApi: ToolAPI): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
+   const allTools: CustomAgentTool<TSchema, unknown>[] = []
+   const enabledFeatures = runtime.features ?? []
 
-  for (const feature of enabledFeatures) {
-    const loader = FEATURE_LOADERS[feature];
-    if (!loader) {
-      console.error(`Unknown exa feature: "${feature}"`);
-      continue;
-    }
+   for (const feature of enabledFeatures) {
+      const loader = FEATURE_LOADERS[feature]
+      if (!loader) {
+         console.error(`Unknown exa feature: "${feature}"`)
+         continue
+      }
 
-    try {
-      const module = await loader();
-      const featureFactory = module.default;
+      try {
+         const module = await loader()
+         const featureFactory = module.default
 
-      if (typeof featureFactory === "function") {
-        const result = await featureFactory(toolApi);
-        // Handle both single tool and array of tools
-        if (result) {
-          const tools = Array.isArray(result) ? result : [result];
-          for (const tool of tools) {
-            if (tool && typeof tool === "object" && "name" in tool) {
-              allTools.push(tool);
+         if (typeof featureFactory === 'function') {
+            const result = await featureFactory(toolApi)
+            // Handle both single tool and array of tools
+            if (result) {
+               const tools = Array.isArray(result) ? result : [result]
+               for (const tool of tools) {
+                  if (tool && typeof tool === 'object' && 'name' in tool) {
+                     allTools.push(tool)
+                  }
+               }
             }
-          }
-        }
+         }
+      } catch (error) {
+         console.error(`Failed to load exa feature "${feature}":`, error)
       }
-    } catch (error) {
-      console.error(`Failed to load exa feature "${feature}":`, error);
-    }
-  }
+   }
 
-  return allTools.length > 0 ? allTools : null;
-};
+   return allTools.length > 0 ? allTools : null
+}
 
-export default factory;
+export default factory

package/tools/linkedin.ts

@@ -5,42 +5,28 @@
  *   - web_search_linkedin: Search LinkedIn profiles and companies
  */
 
-import type { TSchema } from "@sinclair/typebox";
-import type {
-  CustomAgentTool,
-  CustomToolFactory,
-  ToolAPI,
-} from "@mariozechner/pi-coding-agent";
-import {
-  callExaTool,
-  createToolWrapper,
-  fetchExaTools,
-  findApiKey,
-} from "./shared";
+import type { CustomAgentTool, CustomToolFactory, ToolAPI } from '@mariozechner/pi-coding-agent'
+import type { TSchema } from '@sinclair/typebox'
+import { callExaTool, createToolWrapper, fetchExaTools, findApiKey } from './shared'
 
 // MCP tool names for this feature
-const TOOL_NAMES = ["linkedin_search_exa"];
+const TOOL_NAMES = ['linkedin_search_exa']
 
 // Tool name mapping: MCP name -> exposed name
 const NAME_MAP: Record<string, string> = {
-  linkedin_search_exa: "web_search_linkedin",
-};
+   linkedin_search_exa: 'web_search_linkedin',
+}
 
-const factory: CustomToolFactory = async (
-  _toolApi: ToolAPI,
-): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
-  const apiKey = findApiKey();
-  if (!apiKey) return null;
+const factory: CustomToolFactory = async (_toolApi: ToolAPI): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
+   const apiKey = findApiKey()
+   if (!apiKey) return null
 
-  const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES);
-  if (mcpTools.length === 0) return null;
+   const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES)
+   if (mcpTools.length === 0) return null
 
-  const callFn = (toolName: string, args: Record<string, unknown>) =>
-    callExaTool(apiKey, TOOL_NAMES, toolName, args);
+   const callFn = (toolName: string, args: Record<string, unknown>) => callExaTool(apiKey, TOOL_NAMES, toolName, args)
 
-  return mcpTools.map((tool) =>
-    createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn),
-  );
-};
+   return mcpTools.map(tool => createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn))
+}
 
-export default factory;
+export default factory

package/tools/researcher.ts

@@ -3,46 +3,32 @@
  *
  * Tools:
  *   - web_search_researcher_start: Start comprehensive AI research tasks
- *   - web_search_researcher_check: Check research task status
+ *   - web_search_researcher_poll: Check research task status
  */
 
-import type { TSchema } from "@sinclair/typebox";
-import type {
-  CustomAgentTool,
-  CustomToolFactory,
-  ToolAPI,
-} from "@mariozechner/pi-coding-agent";
-import {
-  callExaTool,
-  createToolWrapper,
-  fetchExaTools,
-  findApiKey,
-} from "./shared";
+import type { CustomAgentTool, CustomToolFactory, ToolAPI } from '@mariozechner/pi-coding-agent'
+import type { TSchema } from '@sinclair/typebox'
+import { callExaTool, createToolWrapper, fetchExaTools, findApiKey } from './shared'
 
 // MCP tool names for this feature
-const TOOL_NAMES = ["deep_researcher_start", "deep_researcher_check"];
+const TOOL_NAMES = ['deep_researcher_start', 'deep_researcher_check']
 
 // Tool name mapping: MCP name -> exposed name
 const NAME_MAP: Record<string, string> = {
-  deep_researcher_start: "web_search_researcher_start",
-  deep_researcher_check: "web_search_researcher_check",
-};
+   deep_researcher_start: 'web_search_researcher_start',
+   deep_researcher_check: 'web_search_researcher_poll',
+}
 
-const factory: CustomToolFactory = async (
-  _toolApi: ToolAPI,
-): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
-  const apiKey = findApiKey();
-  if (!apiKey) return null;
+const factory: CustomToolFactory = async (_toolApi: ToolAPI): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
+   const apiKey = findApiKey()
+   if (!apiKey) return null
 
-  const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES);
-  if (mcpTools.length === 0) return null;
+   const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES)
+   if (mcpTools.length === 0) return null
 
-  const callFn = (toolName: string, args: Record<string, unknown>) =>
-    callExaTool(apiKey, TOOL_NAMES, toolName, args);
+   const callFn = (toolName: string, args: Record<string, unknown>) => callExaTool(apiKey, TOOL_NAMES, toolName, args)
 
-  return mcpTools.map((tool) =>
-    createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn),
-  );
-};
+   return mcpTools.map(tool => createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn))
+}
 
-export default factory;
+export default factory

package/tools/search.ts

@@ -2,56 +2,37 @@
  * Exa Search Tools - Core web search capabilities
  *
  * Tools:
- *   - web_search_general: Real-time web searches
+ *   - web_search: Real-time web searches
  *   - web_search_deep: Natural language web search with synthesis
  *   - web_search_code_context: Code search for libraries, docs, examples
- *   - web_search_crawl_url: Extract content from specific URLs
+ *   - web_search_crawl: Extract content from specific URLs
  */
 
-import type { TSchema } from "@sinclair/typebox";
-import type {
-  CustomAgentTool,
-  CustomToolFactory,
-  ToolAPI,
-} from "@mariozechner/pi-coding-agent";
-import {
-  callExaTool,
-  createToolWrapper,
-  fetchExaTools,
-  findApiKey,
-} from "./shared";
+import type { CustomAgentTool, CustomToolFactory, ToolAPI } from '@mariozechner/pi-coding-agent'
+import type { TSchema } from '@sinclair/typebox'
+import { callExaTool, createToolWrapper, fetchExaTools, findApiKey } from './shared'
 
 // MCP tool names for this feature
-const TOOL_NAMES = [
-  "web_search_exa",
-  "deep_search_exa",
-  "get_code_context_exa",
-  "crawling_exa",
-];
+const TOOL_NAMES = ['web_search_exa', 'deep_search_exa', 'get_code_context_exa', 'crawling_exa']
 
 // Tool name mapping: MCP name -> exposed name
 const NAME_MAP: Record<string, string> = {
-  web_search_exa: "web_search_general",
-  deep_search_exa: "web_search_deep",
-  get_code_context_exa: "web_search_code_context",
-  crawling_exa: "web_search_crawl_url",
-};
-
-const factory: CustomToolFactory = async (
-  _toolApi: ToolAPI,
-): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
-  const apiKey = findApiKey();
-  if (!apiKey) return null;
-
-  const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES);
-  if (mcpTools.length === 0) return null;
-
-  const callFn = (toolName: string, args: Record<string, unknown>) =>
-    callExaTool(apiKey, TOOL_NAMES, toolName, args);
-
-  return mcpTools.map((tool) =>
-    createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn),
-  );
-};
-
-export default factory;
+   web_search_exa: 'web_search',
+   deep_search_exa: 'web_search_deep',
+   get_code_context_exa: 'web_search_code_context',
+   crawling_exa: 'web_search_crawl',
+}
+
+const factory: CustomToolFactory = async (_toolApi: ToolAPI): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
+   const apiKey = findApiKey()
+   if (!apiKey) return null
+
+   const mcpTools = await fetchExaTools(apiKey, TOOL_NAMES)
+   if (mcpTools.length === 0) return null
+
+   const callFn = (toolName: string, args: Record<string, unknown>) => callExaTool(apiKey, TOOL_NAMES, toolName, args)
+
+   return mcpTools.map(tool => createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn))
+}
+
+export default factory

package/tools/shared.ts

@@ -2,300 +2,586 @@
  * Shared utilities for Exa MCP tools
  */
 
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import type { TSchema } from "@sinclair/typebox";
-import type { CustomAgentTool } from "@mariozechner/pi-coding-agent";
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import type { CustomAgentTool } from '@mariozechner/pi-coding-agent'
+import { Text } from '@mariozechner/pi-tui'
+import type { TSchema } from '@sinclair/typebox'
 
 // MCP endpoints
-export const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
-export const WEBSETS_MCP_URL = "https://websetsmcp.exa.ai/mcp";
+export const EXA_MCP_URL = 'https://mcp.exa.ai/mcp'
+export const WEBSETS_MCP_URL = 'https://websetsmcp.exa.ai/mcp'
+
+// Log paths
+const EXA_ERROR_LOG = path.join(os.homedir(), '.pi/exa_errors.log')
+const VIEW_ERROR_LOG = path.join(os.homedir(), '.pi/view_errors.log')
+
+function logExaError(msg: string): void {
+   fs.appendFileSync(EXA_ERROR_LOG, `[${new Date().toISOString()}] ${msg}\n`)
+}
+
+function logViewError(msg: string): void {
+   fs.appendFileSync(VIEW_ERROR_LOG, `[${new Date().toISOString()}] ${msg}\n`)
+}
 
 export interface MCPTool {
-  name: string;
-  description: string;
-  inputSchema: TSchema;
+   name: string
+   description: string
+   inputSchema: TSchema
 }
 
 interface MCPToolsResponse {
-  result?: {
-    tools: MCPTool[];
-  };
-  error?: {
-    code: number;
-    message: string;
-  };
+   result?: {
+      tools: MCPTool[]
+   }
+   error?: {
+      code: number
+      message: string
+   }
 }
 
 function normalizeInputSchema(schema: unknown): Record<string, unknown> {
-  if (!schema || typeof schema !== "object") {
-    return { type: "object", properties: {}, required: [] };
-  }
+   if (!schema || typeof schema !== 'object') {
+      return { type: 'object', properties: {}, required: [] }
+   }
 
-  const normalized = { ...(schema as Record<string, unknown>) };
+   const normalized = { ...(schema as Record<string, unknown>) }
 
-  if (!("type" in normalized)) {
-    normalized.type = "object";
-  }
+   if (!('type' in normalized)) {
+      normalized.type = 'object'
+   }
 
-  if (!("properties" in normalized)) {
-    normalized.properties = {};
-  }
+   if (!('properties' in normalized)) {
+      normalized.properties = {}
+   }
 
-  const required = (normalized as { required?: unknown }).required;
-  if (!Array.isArray(required)) {
-    normalized.required = [];
-  }
+   const required = (normalized as { required?: unknown }).required
+   if (!Array.isArray(required)) {
+      normalized.required = []
+   }
 
-  return normalized;
+   return normalized
 }
 
 /**
  * Parse a .env file and return key-value pairs
  */
 function parseEnvFile(filePath: string): Record<string, string> {
-  const result: Record<string, string> = {};
-  if (!fs.existsSync(filePath)) return result;
-
-  try {
-    const content = fs.readFileSync(filePath, "utf-8");
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-
-      const eqIndex = trimmed.indexOf("=");
-      if (eqIndex === -1) continue;
-
-      const key = trimmed.slice(0, eqIndex).trim();
-      let value = trimmed.slice(eqIndex + 1).trim();
-
-      // Remove surrounding quotes
-      if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1);
-      }
+   const result: Record<string, string> = {}
+   if (!fs.existsSync(filePath)) return result
+
+   try {
+      const content = fs.readFileSync(filePath, 'utf-8')
+      for (const line of content.split('\n')) {
+         const trimmed = line.trim()
+         if (!trimmed || trimmed.startsWith('#')) continue
+
+         const eqIndex = trimmed.indexOf('=')
+         if (eqIndex === -1) continue
 
-      result[key] = value;
-    }
-  } catch {
-    // Ignore read errors
-  }
+         const key = trimmed.slice(0, eqIndex).trim()
+         let value = trimmed.slice(eqIndex + 1).trim()
 
-  return result;
+         // Remove surrounding quotes
+         if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1)
+         }
+
+         result[key] = value
+      }
+   } catch {
+      // Ignore read errors
+   }
+
+   return result
 }
 
 /**
  * Find EXA_API_KEY from environment or .env files
  */
 export function findApiKey(): string | null {
-  // 1. Check environment variable
-  if (process.env.EXA_API_KEY) {
-    return process.env.EXA_API_KEY;
-  }
-
-  // 2. Check .env in current directory
-  const localEnv = parseEnvFile(path.join(process.cwd(), ".env"));
-  if (localEnv.EXA_API_KEY) {
-    return localEnv.EXA_API_KEY;
-  }
-
-  // 3. Check ~/.env
-  const homeEnv = parseEnvFile(path.join(os.homedir(), ".env"));
-  if (homeEnv.EXA_API_KEY) {
-    return homeEnv.EXA_API_KEY;
-  }
-
-  return null;
+   // 1. Check environment variable
+   if (process.env.EXA_API_KEY) {
+      return process.env.EXA_API_KEY
+   }
+
+   // 2. Check .env in current directory
+   const localEnv = parseEnvFile(path.join(process.cwd(), '.env'))
+   if (localEnv.EXA_API_KEY) {
+      return localEnv.EXA_API_KEY
+   }
+
+   // 3. Check ~/.env
+   const homeEnv = parseEnvFile(path.join(os.homedir(), '.env'))
+   if (homeEnv.EXA_API_KEY) {
+      return homeEnv.EXA_API_KEY
+   }
+
+   return null
 }
 
 /**
  * Call an MCP server endpoint
  */
-async function callMCP(
-  url: string,
-  method: string,
-  params?: Record<string, unknown>,
-): Promise<unknown> {
-  const body = {
-    jsonrpc: "2.0",
-    method,
-    params: params ?? {},
-    id: 1,
-  };
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json, text/event-stream",
-    },
-    body: JSON.stringify(body),
-  });
-
-  const text = await response.text();
-
-  // Parse SSE response format
-  let jsonData: string | null = null;
-  for (const line of text.split("\n")) {
-    if (line.startsWith("data: ")) {
-      jsonData = line.slice(6);
-      break;
-    }
-  }
-
-  if (!jsonData) {
-    // Try parsing as plain JSON
-    try {
-      return JSON.parse(text);
-    } catch {
-      throw new Error(`Failed to parse MCP response: ${text.slice(0, 500)}`);
-    }
-  }
-
-  return JSON.parse(jsonData);
+async function callMCP(url: string, method: string, params?: Record<string, unknown>): Promise<unknown> {
+   const body = {
+      jsonrpc: '2.0',
+      method,
+      params: params ?? {},
+      id: 1,
+   }
+
+   const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+         'Content-Type': 'application/json',
+         Accept: 'application/json, text/event-stream',
+      },
+      body: JSON.stringify(body),
+   })
+
+   const text = await response.text()
+
+   // Parse SSE response format
+   let jsonData: string | null = null
+   for (const line of text.split('\n')) {
+      if (line.startsWith('data: ')) {
+         jsonData = line.slice(6)
+         break
+      }
+   }
+
+   if (!jsonData) {
+      // Try parsing as plain JSON
+      try {
+         return JSON.parse(text)
+      } catch {
+         throw new Error(`Failed to parse MCP response: ${text.slice(0, 500)}`)
+      }
+   }
+
+   return JSON.parse(jsonData)
 }
 
 /**
  * Fetch available tools from Exa MCP server
  */
-export async function fetchExaTools(
-  apiKey: string,
-  toolNames: string[],
-): Promise<MCPTool[]> {
-  const url = `${EXA_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}&tools=${encodeURIComponent(toolNames.join(","))}`;
-
-  try {
-    const response = (await callMCP(url, "tools/list")) as MCPToolsResponse;
-    if (response.error) {
-      throw new Error(response.error.message);
-    }
-    return response.result?.tools ?? [];
-  } catch (error) {
-    console.error(`Failed to fetch Exa tools:`, error);
-    return [];
-  }
+export async function fetchExaTools(apiKey: string, toolNames: string[]): Promise<MCPTool[]> {
+   const url = `${EXA_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}&tools=${encodeURIComponent(toolNames.join(','))}`
+
+   try {
+      const response = (await callMCP(url, 'tools/list')) as MCPToolsResponse
+      if (response.error) {
+         throw new Error(response.error.message)
+      }
+      return response.result?.tools ?? []
+   } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error)
+      logExaError(`Failed to fetch Exa tools: ${msg}`)
+      return []
+   }
 }
 
 /**
  * Fetch available tools from Websets MCP server
  */
 export async function fetchWebsetsTools(apiKey: string): Promise<MCPTool[]> {
-  const url = `${WEBSETS_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}`;
-
-  try {
-    const response = (await callMCP(url, "tools/list")) as MCPToolsResponse;
-    if (response.error) {
-      throw new Error(response.error.message);
-    }
-    return response.result?.tools ?? [];
-  } catch (error) {
-    console.error(`Failed to fetch Websets tools:`, error);
-    return [];
-  }
+   const url = `${WEBSETS_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}`
+
+   try {
+      const response = (await callMCP(url, 'tools/list')) as MCPToolsResponse
+      if (response.error) {
+         throw new Error(response.error.message)
+      }
+      return response.result?.tools ?? []
+   } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error)
+      logExaError(`Failed to fetch Websets tools: ${msg}`)
+      return []
+   }
 }
 
 /**
  * Call a tool on Exa MCP server
  */
-export async function callExaTool(
-  apiKey: string,
-  toolNames: string[],
-  toolName: string,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const url = `${EXA_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}&tools=${encodeURIComponent(toolNames.join(","))}`;
-  return callMCPTool(url, toolName, args);
+export async function callExaTool(apiKey: string, toolNames: string[], toolName: string, args: Record<string, unknown>): Promise<unknown> {
+   const url = `${EXA_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}&tools=${encodeURIComponent(toolNames.join(','))}`
+   return callMCPTool(url, toolName, args)
 }
 
 /**
  * Call a tool on Websets MCP server
  */
-export async function callWebsetsTool(
-  apiKey: string,
-  toolName: string,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const url = `${WEBSETS_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}`;
-  return callMCPTool(url, toolName, args);
+export async function callWebsetsTool(apiKey: string, toolName: string, args: Record<string, unknown>): Promise<unknown> {
+   const url = `${WEBSETS_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}`
+   return callMCPTool(url, toolName, args)
 }
 
 /**
  * Call a tool on an MCP server
  */
-async function callMCPTool(
-  url: string,
-  toolName: string,
-  args: Record<string, unknown>,
-): Promise<unknown> {
-  const response = (await callMCP(url, "tools/call", {
-    name: toolName,
-    arguments: args,
-  })) as {
-    result?: { content?: Array<{ text?: string }> };
-    error?: { message: string };
-  };
-
-  if (response.error) {
-    throw new Error(response.error.message);
-  }
-
-  // Extract text content from MCP response
-  const content = response.result?.content;
-  if (Array.isArray(content)) {
-    const texts = content.filter((c) => c.text).map((c) => c.text);
-    if (texts.length === 1) {
-      // Try to parse as JSON
-      try {
-        return JSON.parse(texts[0]!);
-      } catch {
-        return texts[0];
+async function callMCPTool(url: string, toolName: string, args: Record<string, unknown>): Promise<unknown> {
+   const response = (await callMCP(url, 'tools/call', {
+      name: toolName,
+      arguments: args,
+   })) as {
+      result?: { content?: Array<{ text?: string }> }
+      error?: { message: string }
+   }
+
+   if (response.error) {
+      throw new Error(response.error.message)
+   }
+
+   // Extract text content from MCP response
+   const content = response.result?.content
+   if (Array.isArray(content)) {
+      const texts = content.filter(c => c.text).map(c => c.text)
+      if (texts.length === 1) {
+         // Try to parse as JSON
+         try {
+            return JSON.parse(texts[0]!)
+         } catch {
+            return texts[0]
+         }
+      }
+      return texts.join('\n\n')
+   }
+
+   return response.result
+}
+
+interface SearchResult {
+   id?: string
+   title?: string
+   url?: string
+   author?: string
+   publishedDate?: string
+   text?: string
+   image?: string
+   favicon?: string
+}
+
+interface SearchResponse {
+   results?: SearchResult[]
+   statuses?: Array<{ id: string; status: string; source?: string }>
+   costDollars?: { total: number }
+   searchTime?: number
+   requestId?: string
+}
+
+/**
+ * Format search results as readable markdown (for LLM consumption)
+ */
+function formatSearchResults(data: SearchResponse): string {
+   const lines: string[] = []
+
+   if (data.results && data.results.length > 0) {
+      for (const result of data.results) {
+         // Title with link
+         if (result.title && result.url) {
+            lines.push(`### [${result.title}](${result.url})`)
+         } else if (result.title) {
+            lines.push(`### ${result.title}`)
+         } else if (result.url) {
+            lines.push(`### ${result.url}`)
+         }
+
+         // Author if present
+         if (result.author) {
+            lines.push(`*by ${result.author}*`)
+         }
+
+         lines.push('')
+
+         // Content - truncate if very long
+         if (result.text) {
+            const text = result.text.trim()
+            const maxLen = 2000
+            if (text.length > maxLen) {
+               lines.push(`${text.slice(0, maxLen)}...`)
+            } else {
+               lines.push(text)
+            }
+         }
+
+         lines.push('')
+         lines.push('---')
+         lines.push('')
+      }
+   }
+
+   // Footer with metadata
+   const meta: string[] = []
+   if (data.results) meta.push(`${data.results.length} result(s)`)
+   if (data.searchTime) meta.push(`${(data.searchTime / 1000).toFixed(2)}s`)
+   if (data.costDollars?.total) meta.push(`$${data.costDollars.total.toFixed(4)}`)
+
+   if (meta.length > 0) {
+      lines.push(`*${meta.join(' • ')}*`)
+   }
+
+   return lines.join('\n')
+}
+
+/**
+ * Check if result looks like a search response
+ */
+function isSearchResponse(data: unknown): data is SearchResponse {
+   if (!data || typeof data !== 'object') return false
+   const obj = data as Record<string, unknown>
+   return Array.isArray(obj.results) || 'searchTime' in obj || 'costDollars' in obj
+}
+
+/**
+ * Parse Exa's markdown text format into a SearchResponse structure
+ * Format: Title: ...\nURL: ...\nAuthor: ...\nPublished Date: ...\nText: ...\n\n (repeated)
+ */
+function parseExaMarkdown(text: string): SearchResponse | null {
+   const results: SearchResult[] = []
+
+   // Split by double newlines to separate results, but be careful with Text: blocks
+   // Each result starts with "Title:"
+   const parts = text.split(/\n(?=Title:)/g)
+
+   for (const part of parts) {
+      if (!part.trim()) continue
+
+      const result: SearchResult = {}
+      const lines = part.split('\n')
+
+      let currentField: string | null = null
+      let textLines: string[] = []
+
+      for (const line of lines) {
+         // Check for field prefixes
+         if (line.startsWith('Title: ')) {
+            result.title = line.slice(7).trim()
+            currentField = null
+         } else if (line.startsWith('URL: ')) {
+            result.url = line.slice(5).trim()
+            currentField = null
+         } else if (line.startsWith('Author: ')) {
+            result.author = line.slice(8).trim()
+            currentField = null
+         } else if (line.startsWith('Published Date: ')) {
+            result.publishedDate = line.slice(16).trim()
+            currentField = null
+         } else if (line.startsWith('Text: ')) {
+            textLines = [line.slice(6)]
+            currentField = 'text'
+         } else if (currentField === 'text') {
+            textLines.push(line)
+         }
+      }
+
+      if (textLines.length > 0) {
+         result.text = textLines.join('\n').trim()
+      }
+
+      if (result.title || result.url) {
+         results.push(result)
       }
-    }
-    return texts.join("\n\n");
-  }
+   }
+
+   if (results.length === 0) return null
+   return { results }
+}
+
+// Tree formatting helpers
+const TREE_MID = '├─'
+const TREE_END = '└─'
+const TREE_PIPE = '│'
+const TREE_SPACE = ' '
+const TREE_HOOK = '⎿'
+
+/**
+ * Truncate text to max length with ellipsis
+ */
+function truncate(text: string, maxLen: number): string {
+   if (text.length <= maxLen) return text
+   return `${text.slice(0, maxLen - 1)}…`
+}
 
-  return response.result;
+/**
+ * Extract domain from URL
+ */
+function getDomain(url: string): string {
+   try {
+      const u = new URL(url)
+      return u.hostname.replace(/^www\./, '')
+   } catch {
+      return url
+   }
+}
+
+/**
+ * Get first N lines of text as preview
+ */
+function getPreviewLines(text: string, maxLines: number, maxLineLen: number): string[] {
+   const lines = text.split('\n').filter(l => l.trim())
+   return lines.slice(0, maxLines).map(l => truncate(l.trim(), maxLineLen))
 }
 
 /**
  * Create a tool wrapper for an MCP tool
  */
 export function createToolWrapper(
-  mcpTool: MCPTool,
-  renamedName: string,
-  callFn: (toolName: string, args: Record<string, unknown>) => Promise<unknown>,
-): CustomAgentTool<TSchema, unknown> {
-  return {
-    name: renamedName,
-    label: renamedName.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
-    description: mcpTool.description,
-    parameters: normalizeInputSchema(mcpTool.inputSchema) as TSchema,
-    async execute(_toolCallId, params) {
-      try {
-        const result = await callFn(
-          mcpTool.name,
-          (params ?? {}) as Record<string, unknown>,
-        );
-        const text =
-          typeof result === "string"
-            ? result
-            : result == null
-              ? "null"
-              : JSON.stringify(result, null, 2) ?? String(result);
-        return {
-          content: [{ type: "text" as const, text }],
-          details: result,
-        };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text" as const, text: `Error: ${message}` }],
-          details: { error: message },
-        };
-      }
-    },
-  };
+   mcpTool: MCPTool,
+   renamedName: string,
+   callFn: (toolName: string, args: Record<string, unknown>) => Promise<unknown>
+): CustomAgentTool<TSchema, SearchResponse | { error: string } | unknown> {
+   return {
+      name: renamedName,
+      label: renamedName.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase()),
+      description: mcpTool.description,
+      parameters: normalizeInputSchema(mcpTool.inputSchema) as TSchema,
+
+      async execute(_toolCallId, params) {
+         try {
+            const result = await callFn(mcpTool.name, (params ?? {}) as Record<string, unknown>)
+
+            let text: string
+            if (typeof result === 'string') {
+               text = result
+            } else if (result == null) {
+               text = 'No results'
+            } else if (isSearchResponse(result)) {
+               text = formatSearchResults(result)
+            } else {
+               text = JSON.stringify(result, null, 2) ?? String(result)
+            }
+
+            return {
+               content: [{ type: 'text' as const, text }],
+               details: result,
+            }
+         } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            return {
+               content: [{ type: 'text' as const, text: `Error: ${message}` }],
+               details: { error: message },
+            }
+         }
+      },
+
+      renderResult(result, { expanded }, theme) {
+         let { details } = result
+
+         // Handle error case
+         if (details && typeof details === 'object' && 'error' in details) {
+            const errDetails = details as { error: string }
+            return new Text(theme.fg('error', `Error: ${errDetails.error}`), 0, 0)
+         }
+
+         // If details is a string (Exa markdown format), try to parse it
+         if (typeof details === 'string') {
+            const parsed = parseExaMarkdown(details)
+            if (parsed) {
+               details = parsed
+            }
+         }
+
+         // Handle non-search responses (plain text/JSON)
+         if (!isSearchResponse(details)) {
+            const text = result.content[0]
+            if (text?.type === 'text') {
+               // For non-search content, show truncated in collapsed, full in expanded
+               if (expanded) {
+                  return new Text(text.text, 0, 0)
+               }
+               const preview = getPreviewLines(text.text, 5, 100)
+               const lines = preview.map(l => theme.fg('dim', l)).join('\n')
+               return new Text(lines + (text.text.split('\n').length > 5 ? theme.fg('muted', '\n  …') : ''), 0, 0)
+            }
+            return new Text('', 0, 0)
+         }
+
+         // Search response - render as tree
+         const data = details as SearchResponse
+         const resultCount = data.results?.length ?? 0
+
+         // Build header with metadata
+         const meta: string[] = []
+         meta.push(`${resultCount} result${resultCount !== 1 ? 's' : ''}`)
+         if (data.searchTime) meta.push(`${(data.searchTime / 1000).toFixed(2)}s`)
+         if (data.costDollars?.total) meta.push(`$${data.costDollars.total.toFixed(4)}`)
+
+         const icon = resultCount > 0 ? theme.fg('success', '●') : theme.fg('warning', '●')
+         const expandHint = expanded ? '' : theme.fg('dim', ' (Ctrl+O to expand)')
+         let text = `${icon} ${theme.fg('toolTitle', 'Web Search')} ${theme.fg('dim', meta.join(' • '))}${expandHint}`
+
+         if (!data.results || data.results.length === 0) {
+            text += `\n ${theme.fg('dim', TREE_END)} ${theme.fg('muted', 'No results found')}`
+            return new Text(text, 0, 0)
+         }
+
+         // Render each result
+         try {
+            for (let i = 0; i < data.results.length; i++) {
+               const r = data.results[i]
+               const isLast = i === data.results.length - 1
+               const branch = isLast ? TREE_END : TREE_MID
+               const cont = isLast ? TREE_SPACE : TREE_PIPE
+
+               // Title line
+               const title = r.title ? truncate(r.title, 80) : 'Untitled'
+               const domain = r.url ? getDomain(r.url) : ''
+               text += `\n ${theme.fg('dim', branch)} ${theme.fg('accent', title)}`
+               if (domain) {
+                  text += theme.fg('dim', ` (${domain})`)
+               }
+
+               // URL line (if different from domain)
+               if (r.url) {
+                  text += `\n ${theme.fg('dim', `${cont}  ${TREE_HOOK} `)}${theme.fg('link', r.url)}`
+               }
+
+               // Author/date metadata
+               const metaParts: string[] = []
+               if (r.author) metaParts.push(`by ${r.author}`)
+               if (r.publishedDate) {
+                  try {
+                     const date = new Date(r.publishedDate)
+                     metaParts.push(date.toLocaleDateString())
+                  } catch {
+                     // ignore invalid dates
+                  }
+               }
+               if (metaParts.length > 0) {
+                  text += `\n ${theme.fg('dim', `${cont}     `)}${theme.fg('muted', metaParts.join(' • '))}`
+               }
+
+               // Content preview (collapsed) or full content (expanded)
+               if (r.text) {
+                  if (expanded) {
+                     // Show full content with proper indentation
+                     const lines = r.text.split('\n')
+                     for (const line of lines) {
+                        if (line.trim()) {
+                           text += `\n ${theme.fg('dim', `${cont}     `)}${theme.fg('dim', line)}`
+                        }
+                     }
+                  } else {
+                     // Show preview (first 2 non-empty lines)
+                     const preview = getPreviewLines(r.text, 2, 100)
+                     for (const line of preview) {
+                        text += `\n ${theme.fg('dim', `${cont}     `)}${theme.fg('dim', line)}`
+                     }
+                     const totalLines = r.text.split('\n').filter(l => l.trim()).length
+                     if (totalLines > 2) {
+                        text += `\n ${theme.fg('dim', `${cont}     `)}${theme.fg('muted', `… ${totalLines - 2} more lines`)}`
+                     }
+                  }
+               }
+            }
+         } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err)
+            logViewError(`exa renderResult error: ${msg}`)
+         }
+
+         return new Text(text, 0, 0)
+      },
+   }
 }

package/tools/websets.ts

@@ -20,54 +20,40 @@
  *   - webset_monitor_create: Auto-update webset on schedule
  */
 
-import type { TSchema } from "@sinclair/typebox";
-import type {
-  CustomAgentTool,
-  CustomToolFactory,
-  ToolAPI,
-} from "@mariozechner/pi-coding-agent";
-import {
-  callWebsetsTool,
-  createToolWrapper,
-  fetchWebsetsTools,
-  findApiKey,
-} from "./shared";
+import type { CustomAgentTool, CustomToolFactory, ToolAPI } from '@mariozechner/pi-coding-agent'
+import type { TSchema } from '@sinclair/typebox'
+import { callWebsetsTool, createToolWrapper, fetchWebsetsTools, findApiKey } from './shared'
 
 // Tool name mapping: MCP name -> exposed name
 const NAME_MAP: Record<string, string> = {
-  create_webset: "webset_create",
-  list_websets: "webset_list",
-  get_webset: "webset_get",
-  update_webset: "webset_update",
-  delete_webset: "webset_delete",
-  list_webset_items: "webset_items_list",
-  get_item: "webset_item_get",
-  create_search: "webset_search_create",
-  get_search: "webset_search_get",
-  cancel_search: "webset_search_cancel",
-  create_enrichment: "webset_enrichment_create",
-  get_enrichment: "webset_enrichment_get",
-  update_enrichment: "webset_enrichment_update",
-  delete_enrichment: "webset_enrichment_delete",
-  cancel_enrichment: "webset_enrichment_cancel",
-  create_monitor: "webset_monitor_create",
-};
+   create_webset: 'webset_create',
+   list_websets: 'webset_list',
+   get_webset: 'webset_get',
+   update_webset: 'webset_update',
+   delete_webset: 'webset_delete',
+   list_webset_items: 'webset_items_list',
+   get_item: 'webset_item_get',
+   create_search: 'webset_search_create',
+   get_search: 'webset_search_get',
+   cancel_search: 'webset_search_cancel',
+   create_enrichment: 'webset_enrichment_create',
+   get_enrichment: 'webset_enrichment_get',
+   update_enrichment: 'webset_enrichment_update',
+   delete_enrichment: 'webset_enrichment_delete',
+   cancel_enrichment: 'webset_enrichment_cancel',
+   create_monitor: 'webset_monitor_create',
+}
 
-const factory: CustomToolFactory = async (
-  _toolApi: ToolAPI,
-): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
-  const apiKey = findApiKey();
-  if (!apiKey) return null;
+const factory: CustomToolFactory = async (_toolApi: ToolAPI): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
+   const apiKey = findApiKey()
+   if (!apiKey) return null
 
-  const mcpTools = await fetchWebsetsTools(apiKey);
-  if (mcpTools.length === 0) return null;
+   const mcpTools = await fetchWebsetsTools(apiKey)
+   if (mcpTools.length === 0) return null
 
-  const callFn = (toolName: string, args: Record<string, unknown>) =>
-    callWebsetsTool(apiKey, toolName, args);
+   const callFn = (toolName: string, args: Record<string, unknown>) => callWebsetsTool(apiKey, toolName, args)
 
-  return mcpTools.map((tool) =>
-    createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn),
-  );
-};
+   return mcpTools.map(tool => createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn))
+}
 
-export default factory;
+export default factory