@oh-my-pi/exa 0.3.0

package/README.md

@@ -0,0 +1,153 @@
+# Exa Plugin
+
+Exa AI web search and websets tools for pi.
+
+## Installation
+
+```bash
+# Install with default features (search only)
+omp install @oh-my-pi/exa
+
+# Install with all features
+omp install @oh-my-pi/exa[*]
+
+# Install with specific features
+omp install @oh-my-pi/exa[search,linkedin,websets]
+```
+
+## Features
+
+| Feature | Default | Description | Tools |
+|---------|---------|-------------|-------|
+| `search` | ✓ | Core web search capabilities | 4 tools |
+| `linkedin` | | LinkedIn profile and company search | 1 tool |
+| `company` | | Comprehensive company research | 1 tool |
+| `researcher` | | Long-running AI research tasks | 2 tools |
+| `websets` | | Entity collection management | 14 tools |
+
+Manage features after install:
+
+```bash
+omp features @oh-my-pi/exa                    # Interactive UI or list features
+omp features @oh-my-pi/exa --enable websets   # Enable websets
+omp features @oh-my-pi/exa --disable search   # Disable search
+omp features @oh-my-pi/exa --set search,linkedin,websets  # Set exact features
+```
+
+Feature state is stored in `runtime.json` which is copied (not symlinked) to the install location. You can also edit it directly:
+
+```bash
+cat ~/.pi/agent/tools/exa/runtime.json
+# {"features": ["search"], "options": {}}
+```
+
+## Setup
+
+Set your Exa API key:
+
+```bash
+# Option 1: Use omp config
+omp config @oh-my-pi/exa apiKey YOUR_API_KEY
+
+# Option 2: Environment variable
+export EXA_API_KEY=YOUR_API_KEY
+
+# Option 3: .env file in current directory or ~/.env
+echo "EXA_API_KEY=YOUR_API_KEY" >> ~/.env
+```
+
+Get your API key from: https://dashboard.exa.ai/api-keys
+
+## Tools
+
+### search (default)
+
+| Tool | Description |
+|------|-------------|
+| `web_search_general` | 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 |
+
+### linkedin
+
+| Tool | Description |
+|------|-------------|
+| `web_search_linkedin` | Search LinkedIn profiles and companies |
+
+### company
+
+| Tool | Description |
+|------|-------------|
+| `web_search_company_research` | 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 |
+
+### websets
+
+| Tool | Description |
+|------|-------------|
+| `webset_create` | Create entity collections with search and enrichments |
+| `webset_list` | List all websets in your account |
+| `webset_get` | Get detailed webset information |
+| `webset_update` | Update webset metadata |
+| `webset_delete` | Delete a webset |
+| `webset_items_list` | List items in a webset |
+| `webset_item_get` | Get item details |
+| `webset_search_create` | Add search to find entities for a webset |
+| `webset_search_get` | Check search status |
+| `webset_search_cancel` | Cancel running search |
+| `webset_enrichment_create` | Extract custom data from webset items |
+| `webset_enrichment_get` | Get enrichment details |
+| `webset_enrichment_update` | Update enrichment metadata |
+| `webset_enrichment_delete` | Delete enrichment |
+| `webset_enrichment_cancel` | Cancel running enrichment |
+| `webset_monitor_create` | Auto-update webset on schedule |
+
+## Usage Examples
+
+### Code Search
+```
+Find examples of how to use React hooks with TypeScript
+```
+
+### Web Search
+```
+Search for the latest news about AI regulation in the EU
+```
+
+### Company Research (requires company feature)
+```
+Research the company OpenAI and find information about their products
+```
+
+### Deep Research (requires researcher feature)
+```
+Start a deep research project on the impact of large language models on software development
+```
+
+### Websets (requires websets feature)
+```
+Create a webset of AI startups in San Francisco founded after 2020,
+find 10 companies and enrich with CEO name and funding amount
+```
+
+## How It Works
+
+The plugin connects to Exa's hosted MCP (Model Context Protocol) servers:
+- `https://mcp.exa.ai/mcp` - Search tools
+- `https://websetsmcp.exa.ai/mcp` - Websets tools
+
+Tools are dynamically fetched from these servers, so you always get the latest available tools.
+
+## Resources
+
+- [Exa Dashboard](https://dashboard.exa.ai/)
+- [Exa MCP Documentation](https://docs.exa.ai/reference/exa-mcp)
+- [Websets MCP Documentation](https://docs.exa.ai/reference/websets-mcp)
+- [Exa API Documentation](https://docs.exa.ai/)

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@oh-my-pi/exa",
+  "version": "0.3.0",
+  "description": "Exa AI web search and websets tools for pi",
+  "keywords": ["omp-plugin", "exa", "web-search", "websets", "ai-search"],
+  "author": "Can Bölük <me@can.ac>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/can1357/oh-my-pi.git",
+    "directory": "plugins/exa"
+  },
+  "omp": {
+    "install": [
+      { "src": "tools/exa/runtime.json", "dest": "agent/tools/exa/runtime.json", "copy": true },
+      { "src": "tools/exa/index.ts", "dest": "agent/tools/exa/index.ts" },
+      { "src": "tools/exa/shared.ts", "dest": "agent/tools/exa/shared.ts" },
+      { "src": "tools/exa/search.ts", "dest": "agent/tools/exa/search.ts" },
+      { "src": "tools/exa/linkedin.ts", "dest": "agent/tools/exa/linkedin.ts" },
+      { "src": "tools/exa/company.ts", "dest": "agent/tools/exa/company.ts" },
+      { "src": "tools/exa/researcher.ts", "dest": "agent/tools/exa/researcher.ts" },
+      { "src": "tools/exa/websets.ts", "dest": "agent/tools/exa/websets.ts" }
+    ],
+    "variables": {
+      "apiKey": {
+        "type": "string",
+        "env": "EXA_API_KEY",
+        "description": "Exa API key for authentication",
+        "required": true
+      }
+    },
+    "features": {
+      "search": {
+        "description": "Core web search (general, deep, code context, URL crawling)",
+        "default": true
+      },
+      "linkedin": {
+        "description": "LinkedIn profile and company search",
+        "default": false
+      },
+      "company": {
+        "description": "Comprehensive company research",
+        "default": false
+      },
+      "researcher": {
+        "description": "Long-running AI research tasks",
+        "default": false
+      },
+      "websets": {
+        "description": "Entity collection management (14 tools)",
+        "default": false
+      }
+    }
+  },
+  "files": ["tools"]
+}

package/tools/exa/company.ts

@@ -0,0 +1,35 @@
+/**
+ * Exa Company Research Tool
+ *
+ * Tools:
+ *   - web_search_company_research: 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";
+
+// MCP tool names for this feature
+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",
+};
+
+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/exa/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Exa Tools - Dynamic loader for feature modules
+ *
+ * Reads runtime.json to determine which features are enabled,
+ * then loads and initializes those feature modules.
+ *
+ * Available features:
+ *   - search: Core web search (general, deep, code context, URL crawling)
+ *   - linkedin: LinkedIn profile and company search
+ *   - company: Comprehensive company research
+ *   - researcher: Long-running AI research tasks
+ *   - 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";
+
+// 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"),
+};
+
+/**
+ * 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 ?? [];
+
+   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;
+
+         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);
+      }
+   }
+
+   return allTools.length > 0 ? allTools : null;
+};
+
+export default factory;

package/tools/exa/linkedin.ts

@@ -0,0 +1,35 @@
+/**
+ * Exa LinkedIn Search Tool
+ *
+ * Tools:
+ *   - 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";
+
+// MCP tool names for this feature
+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",
+};
+
+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/exa/researcher.ts

@@ -0,0 +1,40 @@
+/**
+ * Exa Deep Researcher Tools
+ *
+ * Tools:
+ *   - web_search_researcher_start: Start comprehensive AI research tasks
+ *   - web_search_researcher_check: 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";
+
+// MCP tool names for this feature
+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",
+};
+
+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/exa/runtime.json

@@ -0,0 +1,4 @@
+{
+  "features": ["search"],
+  "options": {}
+}

package/tools/exa/search.ts

@@ -0,0 +1,46 @@
+/**
+ * Exa Search Tools - Core web search capabilities
+ *
+ * Tools:
+ *   - web_search_general: 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
+ */
+
+import type { TSchema } from "@sinclair/typebox";
+import type { CustomAgentTool, CustomToolFactory, ToolAPI } from "@mariozechner/pi-coding-agent";
+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",
+];
+
+// 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;

package/tools/exa/shared.ts

@@ -0,0 +1,230 @@
+/**
+ * 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";
+
+// MCP endpoints
+export const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
+export const WEBSETS_MCP_URL = "https://websetsmcp.exa.ai/mcp";
+
+export interface MCPTool {
+   name: string;
+   description: string;
+   inputSchema: TSchema;
+}
+
+interface MCPToolsResponse {
+   result?: {
+      tools: MCPTool[];
+   };
+   error?: {
+      code: number;
+      message: string;
+   };
+}
+
+/**
+ * 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);
+         }
+
+         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;
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Fetch available tools from Exa MCP server
+ */
+export async function fetchExaTools(apiKey: string, toolNames: string[]): Promise<MCPTool[]> {
+   const url = `${EXA_MCP_URL}?exaApiKey=${apiKey}&tools=${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 [];
+   }
+}
+
+/**
+ * Fetch available tools from Websets MCP server
+ */
+export async function fetchWebsetsTools(apiKey: string): Promise<MCPTool[]> {
+   const url = `${WEBSETS_MCP_URL}?exaApiKey=${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 [];
+   }
+}
+
+/**
+ * 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=${apiKey}&tools=${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=${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];
+         }
+      }
+      return texts.join("\n\n");
+   }
+
+   return response.result;
+}
+
+/**
+ * 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,
+      description: mcpTool.description,
+      parameters: mcpTool.inputSchema,
+      async execute(args) {
+         return callFn(mcpTool.name, args as Record<string, unknown>);
+      },
+   };
+}

package/tools/exa/websets.ts

@@ -0,0 +1,62 @@
+/**
+ * Exa Websets Tools - Entity collection management
+ *
+ * Tools:
+ *   - webset_create: Create entity collections with search/enrichments
+ *   - webset_list: List all websets
+ *   - webset_get: Get webset details
+ *   - webset_update: Update webset metadata
+ *   - webset_delete: Delete a webset
+ *   - webset_items_list: List items in a webset
+ *   - webset_item_get: Get item details
+ *   - webset_search_create: Add search to webset
+ *   - webset_search_get: Check search status
+ *   - webset_search_cancel: Cancel running search
+ *   - webset_enrichment_create: Extract custom data from items
+ *   - webset_enrichment_get: Get enrichment details
+ *   - webset_enrichment_update: Update enrichment metadata
+ *   - webset_enrichment_delete: Delete enrichment
+ *   - webset_enrichment_cancel: Cancel running enrichment
+ *   - 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";
+
+// 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",
+};
+
+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 callFn = (toolName: string, args: Record<string, unknown>) =>
+      callWebsetsTool(apiKey, toolName, args);
+
+   return mcpTools.map((tool) =>
+      createToolWrapper(tool, NAME_MAP[tool.name] ?? tool.name, callFn)
+   );
+};
+
+export default factory;