openclaw-exa-search 1.0.4 → 2.0.0

package/README.md

@@ -54,6 +54,7 @@ npm install
 npm run typecheck
 npm test              # unit tests
 npm run test:integration  # integration tests (hits real Exa endpoint)
+npm run build
 ```
 
 ## Notes

package/dist/exa-mcp-client.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Exa MCP Client — HTTP/SSE communication with Exa hosted MCP endpoint
+ * No API key required; uses mcp.exa.ai with all tools enabled
+ */
+interface ExaSuccessResponse {
+    jsonrpc: "2.0";
+    id: number;
+    result: {
+        content?: Array<{
+            type: string;
+            text: string;
+        }>;
+        tools?: Array<{
+            name: string;
+            description: string;
+            inputSchema: unknown;
+        }>;
+    };
+}
+interface ExaErrorResponse {
+    jsonrpc: "2.0";
+    id: number;
+    error: {
+        code: number;
+        message: string;
+    };
+}
+type ExaResponse = ExaSuccessResponse | ExaErrorResponse;
+/**
+ * Parse SSE response — extract the last complete JSON-RPC message.
+ * Per SSE spec, multiple `data:` lines within one event are joined with "\n",
+ * but Exa sends one JSON object per `data:` line. We take the last `data:` line
+ * that parses as valid JSON to handle both single and multi-event streams.
+ */
+export declare function parseSSEResponse(text: string): string;
+/**
+ * Call an Exa MCP tool
+ */
+export declare function callExa(method: string, params?: Record<string, unknown>, fetchFn?: typeof fetch): Promise<ExaResponse>;
+/**
+ * Extract text content from an Exa response
+ */
+export declare function extractTextContent(response: ExaResponse): string;
+export declare function webSearch(params: {
+    query: string;
+    numResults?: number;
+    type?: "auto" | "fast" | "deep";
+    livecrawl?: "fallback" | "preferred";
+}): Promise<string>;
+export declare function codeSearch(params: {
+    query: string;
+    tokensNum?: number;
+}): Promise<string>;
+export declare function companyResearch(params: {
+    companyName: string;
+    numResults?: number;
+}): Promise<string>;
+export declare function twitterSearch(params: {
+    query: string;
+    numResults?: number;
+    startPublishedDate?: string;
+    endPublishedDate?: string;
+}): Promise<string>;
+export declare function peopleSearch(params: {
+    query: string;
+    numResults?: number;
+}): Promise<string>;
+export declare function financialSearch(params: {
+    query: string;
+    numResults?: number;
+    startPublishedDate?: string;
+    endPublishedDate?: string;
+}): Promise<string>;
+export {};

package/dist/exa-mcp-client.js

@@ -0,0 +1,168 @@
+/**
+ * Exa MCP Client — HTTP/SSE communication with Exa hosted MCP endpoint
+ * No API key required; uses mcp.exa.ai with all tools enabled
+ */
+const EXA_BASE_URL = "https://mcp.exa.ai/mcp";
+const EXA_TOOLS = [
+    "web_search_exa",
+    "web_search_advanced_exa",
+    "get_code_context_exa",
+    "company_research_exa",
+    "people_search_exa",
+].join(",");
+const EXA_URL = `${EXA_BASE_URL}?tools=${EXA_TOOLS}`;
+const REQUEST_TIMEOUT_MS = 30_000;
+let requestIdCounter = 0;
+/**
+ * Parse SSE response — extract the last complete JSON-RPC message.
+ * Per SSE spec, multiple `data:` lines within one event are joined with "\n",
+ * but Exa sends one JSON object per `data:` line. We take the last `data:` line
+ * that parses as valid JSON to handle both single and multi-event streams.
+ */
+export function parseSSEResponse(text) {
+    const lines = text.split("\n");
+    const dataLines = [];
+    for (const line of lines) {
+        if (line.startsWith("data: ")) {
+            dataLines.push(line.substring(6));
+        }
+    }
+    if (dataLines.length === 0) {
+        throw new Error("No data: field found in SSE response");
+    }
+    // Try each data line from last to first — return the first valid JSON
+    for (let i = dataLines.length - 1; i >= 0; i--) {
+        try {
+            JSON.parse(dataLines[i]);
+            return dataLines[i];
+        }
+        catch {
+            // not valid JSON, try next
+        }
+    }
+    // Fallback: join all and let caller handle parse error
+    return dataLines.join("");
+}
+/**
+ * Call an Exa MCP tool
+ */
+export async function callExa(method, params, fetchFn = fetch) {
+    const requestId = ++requestIdCounter;
+    const request = {
+        jsonrpc: "2.0",
+        id: requestId,
+        method,
+        params,
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetchFn(EXA_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json, text/event-stream",
+            },
+            body: JSON.stringify(request),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+        }
+        const text = await response.text();
+        // Try JSON first, fallback to SSE parsing
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const jsonData = parseSSEResponse(text);
+            return JSON.parse(jsonData);
+        }
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+            throw new Error(`Exa request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Extract text content from an Exa response
+ */
+export function extractTextContent(response) {
+    if ("error" in response) {
+        throw new Error(`Exa API error: ${response.error.code} - ${response.error.message}`);
+    }
+    const result = response.result;
+    if (!result?.content) {
+        throw new Error("No content in response");
+    }
+    return result.content
+        .filter((item) => item.type === "text")
+        .map((item) => item.text)
+        .join("\n\n");
+}
+// ─── Tool Functions ────────────────────────────────────────────────
+export async function webSearch(params) {
+    const response = await callExa("tools/call", {
+        name: "web_search_exa",
+        arguments: params,
+    });
+    return extractTextContent(response);
+}
+export async function codeSearch(params) {
+    const response = await callExa("tools/call", {
+        name: "get_code_context_exa",
+        arguments: params,
+    });
+    return extractTextContent(response);
+}
+export async function companyResearch(params) {
+    const response = await callExa("tools/call", {
+        name: "company_research_exa",
+        arguments: params,
+    });
+    return extractTextContent(response);
+}
+export async function twitterSearch(params) {
+    const args = {
+        query: params.query,
+        category: "tweet",
+        numResults: params.numResults ?? 10,
+    };
+    if (params.startPublishedDate !== undefined)
+        args.startPublishedDate = params.startPublishedDate;
+    if (params.endPublishedDate !== undefined)
+        args.endPublishedDate = params.endPublishedDate;
+    const response = await callExa("tools/call", {
+        name: "web_search_advanced_exa",
+        arguments: args,
+    });
+    return extractTextContent(response);
+}
+export async function peopleSearch(params) {
+    const response = await callExa("tools/call", {
+        name: "people_search_exa",
+        arguments: params,
+    });
+    return extractTextContent(response);
+}
+export async function financialSearch(params) {
+    const args = {
+        query: params.query,
+        category: "financial report",
+        numResults: params.numResults ?? 10,
+    };
+    if (params.startPublishedDate !== undefined)
+        args.startPublishedDate = params.startPublishedDate;
+    if (params.endPublishedDate !== undefined)
+        args.endPublishedDate = params.endPublishedDate;
+    const response = await callExa("tools/call", {
+        name: "web_search_advanced_exa",
+        arguments: args,
+    });
+    return extractTextContent(response);
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OpenClaw Exa Search Plugin
+ *
+ * Registers 6 tools: web_search, code_search, company_research,
+ * twitter_search, people_search, financial_report_search
+ */
+import type { OpenClawPluginApi, AnyAgentTool } from "openclaw/plugin-sdk/plugin-entry";
+declare const TOOLS: AnyAgentTool[];
+declare const _default: {
+    id: string;
+    name: string;
+    description: string;
+    register(api: OpenClawPluginApi): void;
+};
+export default _default;
+export { TOOLS };

package/dist/index.js

@@ -0,0 +1,137 @@
+/**
+ * OpenClaw Exa Search Plugin
+ *
+ * Registers 6 tools: web_search, code_search, company_research,
+ * twitter_search, people_search, financial_report_search
+ */
+import { Type } from "@sinclair/typebox";
+import { webSearch, codeSearch, companyResearch, twitterSearch, peopleSearch, financialSearch, } from "./exa-mcp-client.js";
+// ─── Helper ────────────────────────────────────────────────────────
+function wrapExecute(fn) {
+    return async (_id, params) => {
+        try {
+            const result = await fn(params);
+            return { content: [{ type: "text", text: result }], details: {} };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                details: { isError: true },
+            };
+        }
+    };
+}
+// ─── Tool definitions ──────────────────────────────────────────────
+const TOOLS = [
+    {
+        name: "exa_web_search",
+        label: "Exa Web Search",
+        description: "Search the web using Exa AI neural search. Find current information, news, facts, or answer questions about any topic. Returns clean, formatted content ready for LLM use.",
+        parameters: Type.Object({
+            query: Type.String({ description: "Web search query" }),
+            numResults: Type.Optional(Type.Number({ description: "Number of search results to return (default: 8)" })),
+            type: Type.Optional(Type.Union([Type.Literal("auto"), Type.Literal("fast"), Type.Literal("deep")], {
+                description: "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive research",
+            })),
+            livecrawl: Type.Optional(Type.Union([Type.Literal("fallback"), Type.Literal("preferred")], {
+                description: "Live crawl mode - 'fallback': use live crawling as backup if cached unavailable, 'preferred': prioritize live crawling",
+            })),
+        }),
+        execute: wrapExecute(webSearch),
+    },
+    {
+        name: "exa_code_search",
+        label: "Exa Code Search",
+        description: "Find code examples, documentation, and programming solutions from GitHub, Stack Overflow, and official docs. Useful for API usage, library examples, code snippets, and debugging help.",
+        parameters: Type.Object({
+            query: Type.String({
+                description: "Search query for code context - e.g., 'React useState hook examples', 'Python pandas dataframe filtering'",
+            }),
+            tokensNum: Type.Optional(Type.Number({
+                description: "Number of tokens to return (1000-50000). Lower for focused queries, higher for comprehensive docs (default: 5000)",
+            })),
+        }),
+        execute: wrapExecute(codeSearch),
+    },
+    {
+        name: "exa_company_research",
+        label: "Exa Company Research",
+        description: "Research any company to get business information, news, and insights. Returns information from trusted business sources about products, services, recent news, or industry position.",
+        parameters: Type.Object({
+            companyName: Type.String({
+                description: "Name of the company to research",
+            }),
+            numResults: Type.Optional(Type.Number({
+                description: "Number of search results to return (default: 5)",
+            })),
+        }),
+        execute: wrapExecute(companyResearch),
+    },
+    {
+        name: "exa_twitter_search",
+        label: "Exa Twitter Search",
+        description: "Search Twitter/X posts. Find tweets, discussions, and social commentary on any topic. Useful for tracking public sentiment, announcements, and trending discussions.",
+        parameters: Type.Object({
+            query: Type.String({
+                description: "Search query for Twitter/X posts",
+            }),
+            numResults: Type.Optional(Type.Number({
+                description: "Number of tweets to return (default: 10)",
+            })),
+            startPublishedDate: Type.Optional(Type.String({
+                description: "Filter tweets published after this date (ISO 8601 format, e.g., '2024-01-01T00:00:00.000Z')",
+            })),
+            endPublishedDate: Type.Optional(Type.String({
+                description: "Filter tweets published before this date (ISO 8601 format)",
+            })),
+        }),
+        execute: wrapExecute(twitterSearch),
+    },
+    {
+        name: "exa_people_search",
+        label: "Exa People Search",
+        description: "Find people and their professional profiles. Search for individuals by name, role, company, or expertise. Returns public LinkedIn and professional profile data.",
+        parameters: Type.Object({
+            query: Type.String({
+                description: "Search query for people - e.g., 'CTO at Anthropic', 'machine learning researchers Stanford'",
+            }),
+            numResults: Type.Optional(Type.Number({
+                description: "Number of results to return (default: 5)",
+            })),
+        }),
+        execute: wrapExecute(peopleSearch),
+    },
+    {
+        name: "exa_financial_report_search",
+        label: "Exa Financial Report Search",
+        description: "Search financial reports — 10-K, 10-Q, annual reports, quarterly earnings, and SEC filings for public companies.",
+        parameters: Type.Object({
+            query: Type.String({
+                description: "Search query for financial reports - e.g., 'Apple 2024 Q4 earnings', 'Tesla annual report 2024'",
+            }),
+            numResults: Type.Optional(Type.Number({
+                description: "Number of results to return (default: 10)",
+            })),
+            startPublishedDate: Type.Optional(Type.String({
+                description: "Filter reports published after this date (ISO 8601 format)",
+            })),
+            endPublishedDate: Type.Optional(Type.String({
+                description: "Filter reports published before this date (ISO 8601 format)",
+            })),
+        }),
+        execute: wrapExecute(financialSearch),
+    },
+];
+// ─── Plugin entry ──────────────────────────────────────────────────
+export default {
+    id: "openclaw-exa-search",
+    name: "Exa Search",
+    description: "Exa AI search integration for OpenClaw — web, code, company, Twitter/X, people, and financial report search. No API key required.",
+    register(api) {
+        for (const tool of TOOLS) {
+            api.registerTool(tool);
+        }
+    },
+};
+export { TOOLS };

package/dist/integration.spec.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Integration tests — hits real Exa MCP endpoint
+ * Run with: npm run test:integration
+ */
+export {};

package/dist/integration.spec.js

@@ -0,0 +1,45 @@
+/**
+ * Integration tests — hits real Exa MCP endpoint
+ * Run with: npm run test:integration
+ */
+import { describe, it, expect } from "vitest";
+import { webSearch, codeSearch, companyResearch, twitterSearch, peopleSearch, financialSearch, } from "./exa-mcp-client.js";
+const TIMEOUT = 30_000;
+describe("integration: Exa MCP endpoint", () => {
+    it("exa_web_search", async () => {
+        const result = await webSearch({ query: "OpenAI latest news", numResults: 3 });
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(50);
+        console.log("[web_search] ✅", result.slice(0, 200), "...");
+    }, TIMEOUT);
+    it("exa_code_search", async () => {
+        const result = await codeSearch({ query: "React useState hook examples", tokensNum: 2000 });
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(50);
+        console.log("[code_search] ✅", result.slice(0, 200), "...");
+    }, TIMEOUT);
+    it("exa_company_research", async () => {
+        const result = await companyResearch({ companyName: "Anthropic", numResults: 3 });
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(50);
+        console.log("[company_research] ✅", result.slice(0, 200), "...");
+    }, TIMEOUT);
+    it("exa_twitter_search", async () => {
+        const result = await twitterSearch({ query: "AI agents", numResults: 5 });
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(50);
+        console.log("[twitter_search] ✅", result.slice(0, 200), "...");
+    }, TIMEOUT);
+    it("exa_people_search", async () => {
+        const result = await peopleSearch({ query: "CTO at Anthropic", numResults: 3 });
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(50);
+        console.log("[people_search] ✅", result.slice(0, 200), "...");
+    }, TIMEOUT);
+    it("exa_financial_search", async () => {
+        const result = await financialSearch({ query: "Apple 2024 annual report", numResults: 3 });
+        expect(result).toBeTruthy();
+        expect(result.length).toBeGreaterThan(50);
+        console.log("[financial_search] ✅", result.slice(0, 200), "...");
+    }, TIMEOUT);
+});

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-exa-search",
   "name": "Exa Search",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "description": "Exa AI search integration for OpenClaw — web, code, company, Twitter/X, people, and financial report search. No API key required.",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,32 +1,63 @@
 {
   "name": "openclaw-exa-search",
-  "version": "1.0.4",
+  "version": "2.0.0",
+  "type": "module",
   "description": "Exa AI search integration for OpenClaw — web, code, company, Twitter/X, people, and financial report search. No API key required.",
   "engines": {
     "node": ">=18"
   },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
+    "build": "tsc",
     "test": "vitest run",
     "test:integration": "vitest run --config vitest.integration.config.ts",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   },
-  "keywords": ["openclaw", "openclaw-plugin", "exa", "search", "web-search", "code-search", "company-research", "twitter-search", "people-search", "financial-reports", "ai", "neural-search", "mcp"],
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "exa",
+    "search",
+    "web-search",
+    "code-search",
+    "company-research",
+    "twitter-search",
+    "people-search",
+    "financial-reports",
+    "ai",
+    "neural-search",
+    "mcp"
+  ],
   "author": "sawyer0x110",
   "license": "MIT",
   "openclaw": {
-    "extensions": ["./src/index.ts"]
+    "extensions": [
+      "./dist/index.js"
+    ]
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/sawyer0x110/openclaw-exa-search"
   },
+  "peerDependencies": {
+    "openclaw": ">=2025.0.0"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.0"
+  },
   "devDependencies": {
     "typescript": "^5.7.0",
     "vitest": "^3.0.0"
   },
   "files": [
-    "src",
+    "dist",
     "openclaw.plugin.json",
     "README.md"
   ]

package/src/exa-mcp-client.test.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { parseSSEResponse, extractTextContent, callExa } from "./exa-mcp-client";
-
-describe("parseSSEResponse", () => {
-  it("extracts data from SSE format", () => {
-    const sse = 'event: message\ndata: {"jsonrpc":"2.0","id":1,"result":{}}\n\n';
-    expect(parseSSEResponse(sse)).toBe('{"jsonrpc":"2.0","id":1,"result":{}}');
-  });
-
-  it("throws when no data field", () => {
-    expect(() => parseSSEResponse("event: message\n")).toThrow(
-      "No data: field found"
-    );
-  });
-
-  it("returns last valid JSON data line from multi-line SSE", () => {
-    const sse =
-      'data: {"jsonrpc":"2.0","id":1,"result":{"content":[]}}\ndata: {"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"final"}]}}\n';
-    const result = parseSSEResponse(sse);
-    expect(JSON.parse(result).result.content[0].text).toBe("final");
-  });
-
-  it("falls back to concatenation when no line is valid JSON", () => {
-    const sse = "data: not-json-a\ndata: not-json-b\n";
-    expect(parseSSEResponse(sse)).toBe("not-json-anot-json-b");
-  });
-});
-
-describe("extractTextContent", () => {
-  it("extracts text from valid response", () => {
-    const response = {
-      jsonrpc: "2.0" as const,
-      id: 1,
-      result: {
-        content: [
-          { type: "text", text: "Hello" },
-          { type: "text", text: "World" },
-        ],
-      },
-    };
-    expect(extractTextContent(response)).toBe("Hello\n\nWorld");
-  });
-
-  it("throws on API error", () => {
-    const response = {
-      jsonrpc: "2.0" as const,
-      id: 1,
-      error: { code: 400, message: "Bad request" },
-    };
-    expect(() => extractTextContent(response)).toThrow("Exa API error: 400");
-  });
-
-  it("throws on missing content", () => {
-    const response = {
-      jsonrpc: "2.0" as const,
-      id: 1,
-      result: {},
-    };
-    expect(() => extractTextContent(response)).toThrow("No content");
-  });
-
-  it("filters non-text content types", () => {
-    const response = {
-      jsonrpc: "2.0" as const,
-      id: 1,
-      result: {
-        content: [
-          { type: "image", text: "ignored" },
-          { type: "text", text: "kept" },
-        ],
-      },
-    };
-    expect(extractTextContent(response)).toBe("kept");
-  });
-});
-
-describe("callExa", () => {
-  function mockFetch(body: unknown, status = 200): typeof fetch {
-    return vi.fn().mockResolvedValue({
-      ok: status >= 200 && status < 300,
-      status,
-      statusText: status === 200 ? "OK" : "Bad Request",
-      text: () => Promise.resolve(typeof body === "string" ? body : JSON.stringify(body)),
-    });
-  }
-
-  it("sends correct JSON-RPC request and parses JSON response", async () => {
-    const responseBody = {
-      jsonrpc: "2.0",
-      id: 1,
-      result: { content: [{ type: "text", text: "ok" }] },
-    };
-    const fetchFn = mockFetch(responseBody);
-
-    const result = await callExa("tools/call", { name: "web_search_exa", arguments: { query: "test" } }, fetchFn);
-
-    expect(fetchFn).toHaveBeenCalledTimes(1);
-    const [url, opts] = (fetchFn as any).mock.calls[0];
-    expect(url).toContain("mcp.exa.ai");
-    expect(opts.method).toBe("POST");
-    expect(opts.headers["Content-Type"]).toBe("application/json");
-
-    const body = JSON.parse(opts.body);
-    expect(body.jsonrpc).toBe("2.0");
-    expect(body.method).toBe("tools/call");
-    expect(body.params.name).toBe("web_search_exa");
-
-    expect((result as any).result.content[0].text).toBe("ok");
-  });
-
-  it("falls back to SSE parsing when response is not JSON", async () => {
-    const sseBody = 'event: message\ndata: {"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"sse"}]}}\n\n';
-    const fetchFn = mockFetch(sseBody);
-
-    const result = await callExa("tools/call", { name: "web_search_exa", arguments: {} }, fetchFn);
-    expect((result as any).result.content[0].text).toBe("sse");
-  });
-
-  it("throws on HTTP error", async () => {
-    const fetchFn = mockFetch("Bad Request", 400);
-    await expect(callExa("tools/call", {}, fetchFn)).rejects.toThrow("HTTP error: 400");
-  });
-
-  it("throws descriptive timeout error on abort", async () => {
-    const fetchFn = vi.fn().mockImplementation(() => {
-      const err = new DOMException("The operation was aborted", "AbortError");
-      return Promise.reject(err);
-    });
-
-    await expect(callExa("tools/call", {}, fetchFn)).rejects.toThrow("timed out");
-  });
-});

package/src/exa-mcp-client.ts

@@ -1,242 +0,0 @@
-/**
- * Exa MCP Client — HTTP/SSE communication with Exa hosted MCP endpoint
- * No API key required; uses mcp.exa.ai with all tools enabled
- */
-
-const EXA_BASE_URL = "https://mcp.exa.ai/mcp";
-
-const EXA_TOOLS = [
-  "web_search_exa",
-  "web_search_advanced_exa",
-  "get_code_context_exa",
-  "company_research_exa",
-  "people_search_exa",
-].join(",");
-
-const EXA_URL = `${EXA_BASE_URL}?tools=${EXA_TOOLS}`;
-
-const REQUEST_TIMEOUT_MS = 30_000;
-
-let requestIdCounter = 0;
-
-interface ExaRequest {
-  jsonrpc: "2.0";
-  id: number;
-  method: string;
-  params?: Record<string, unknown>;
-}
-
-interface ExaSuccessResponse {
-  jsonrpc: "2.0";
-  id: number;
-  result: {
-    content?: Array<{ type: string; text: string }>;
-    tools?: Array<{ name: string; description: string; inputSchema: unknown }>;
-  };
-}
-
-interface ExaErrorResponse {
-  jsonrpc: "2.0";
-  id: number;
-  error: {
-    code: number;
-    message: string;
-  };
-}
-
-type ExaResponse = ExaSuccessResponse | ExaErrorResponse;
-
-/**
- * Parse SSE response — extract the last complete JSON-RPC message.
- * Per SSE spec, multiple `data:` lines within one event are joined with "\n",
- * but Exa sends one JSON object per `data:` line. We take the last `data:` line
- * that parses as valid JSON to handle both single and multi-event streams.
- */
-export function parseSSEResponse(text: string): string {
-  const lines = text.split("\n");
-  const dataLines: string[] = [];
-  for (const line of lines) {
-    if (line.startsWith("data: ")) {
-      dataLines.push(line.substring(6));
-    }
-  }
-  if (dataLines.length === 0) {
-    throw new Error("No data: field found in SSE response");
-  }
-  // Try each data line from last to first — return the first valid JSON
-  for (let i = dataLines.length - 1; i >= 0; i--) {
-    try {
-      JSON.parse(dataLines[i]);
-      return dataLines[i];
-    } catch {
-      // not valid JSON, try next
-    }
-  }
-  // Fallback: join all and let caller handle parse error
-  return dataLines.join("");
-}
-
-/**
- * Call an Exa MCP tool
- */
-export async function callExa(
-  method: string,
-  params?: Record<string, unknown>,
-  fetchFn: typeof fetch = fetch
-): Promise<ExaResponse> {
-  const requestId = ++requestIdCounter;
-
-  const request: ExaRequest = {
-    jsonrpc: "2.0",
-    id: requestId,
-    method,
-    params,
-  };
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-
-  try {
-    const response = await fetchFn(EXA_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json, text/event-stream",
-      },
-      body: JSON.stringify(request),
-      signal: controller.signal,
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-    }
-
-    const text = await response.text();
-
-    // Try JSON first, fallback to SSE parsing
-    try {
-      return JSON.parse(text) as ExaResponse;
-    } catch {
-      const jsonData = parseSSEResponse(text);
-      return JSON.parse(jsonData) as ExaResponse;
-    }
-  } catch (error: unknown) {
-    if (error instanceof DOMException && error.name === "AbortError") {
-      throw new Error(`Exa request timed out after ${REQUEST_TIMEOUT_MS / 1000}s`);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-/**
- * Extract text content from an Exa response
- */
-export function extractTextContent(response: ExaResponse): string {
-  if ("error" in response) {
-    throw new Error(
-      `Exa API error: ${response.error.code} - ${response.error.message}`
-    );
-  }
-
-  const result = (response as ExaSuccessResponse).result;
-  if (!result?.content) {
-    throw new Error("No content in response");
-  }
-
-  return result.content
-    .filter((item) => item.type === "text")
-    .map((item) => item.text)
-    .join("\n\n");
-}
-
-// ─── Tool Functions ────────────────────────────────────────────────
-
-export async function webSearch(params: {
-  query: string;
-  numResults?: number;
-  type?: "auto" | "fast" | "deep";
-  livecrawl?: "fallback" | "preferred";
-}): Promise<string> {
-  const response = await callExa("tools/call", {
-    name: "web_search_exa",
-    arguments: params,
-  });
-  return extractTextContent(response);
-}
-
-export async function codeSearch(params: {
-  query: string;
-  tokensNum?: number;
-}): Promise<string> {
-  const response = await callExa("tools/call", {
-    name: "get_code_context_exa",
-    arguments: params,
-  });
-  return extractTextContent(response);
-}
-
-export async function companyResearch(params: {
-  companyName: string;
-  numResults?: number;
-}): Promise<string> {
-  const response = await callExa("tools/call", {
-    name: "company_research_exa",
-    arguments: params,
-  });
-  return extractTextContent(response);
-}
-
-export async function twitterSearch(params: {
-  query: string;
-  numResults?: number;
-  startPublishedDate?: string;
-  endPublishedDate?: string;
-}): Promise<string> {
-  const args: Record<string, unknown> = {
-    query: params.query,
-    category: "tweet",
-    numResults: params.numResults ?? 10,
-  };
-  if (params.startPublishedDate !== undefined) args.startPublishedDate = params.startPublishedDate;
-  if (params.endPublishedDate !== undefined) args.endPublishedDate = params.endPublishedDate;
-
-  const response = await callExa("tools/call", {
-    name: "web_search_advanced_exa",
-    arguments: args,
-  });
-  return extractTextContent(response);
-}
-
-export async function peopleSearch(params: {
-  query: string;
-  numResults?: number;
-}): Promise<string> {
-  const response = await callExa("tools/call", {
-    name: "people_search_exa",
-    arguments: params,
-  });
-  return extractTextContent(response);
-}
-
-export async function financialSearch(params: {
-  query: string;
-  numResults?: number;
-  startPublishedDate?: string;
-  endPublishedDate?: string;
-}): Promise<string> {
-  const args: Record<string, unknown> = {
-    query: params.query,
-    category: "financial report",
-    numResults: params.numResults ?? 10,
-  };
-  if (params.startPublishedDate !== undefined) args.startPublishedDate = params.startPublishedDate;
-  if (params.endPublishedDate !== undefined) args.endPublishedDate = params.endPublishedDate;
-
-  const response = await callExa("tools/call", {
-    name: "web_search_advanced_exa",
-    arguments: args,
-  });
-  return extractTextContent(response);
-}

package/src/index.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import pluginInit, { TOOLS } from "./index";
-
-describe("plugin registration", () => {
-  it("registers all 6 tools", () => {
-    const registered: string[] = [];
-    const api = {
-      registerTool: vi.fn((tool: any) => registered.push(tool.name)),
-    };
-
-    pluginInit(api);
-
-    expect(registered).toEqual([
-      "exa_web_search",
-      "exa_code_search",
-      "exa_company_research",
-      "exa_twitter_search",
-      "exa_people_search",
-      "exa_financial_report_search",
-    ]);
-    expect(api.registerTool).toHaveBeenCalledTimes(6);
-  });
-});
-
-describe("tool definitions", () => {
-  it("all tools have required fields", () => {
-    for (const tool of TOOLS) {
-      expect(tool.name).toMatch(/^exa_/);
-      expect(tool.description).toBeTruthy();
-      expect(tool.parameters).toBeDefined();
-      expect(typeof tool.execute).toBe("function");
-
-      const required = (tool.parameters as any).required;
-      expect(required.length).toBeGreaterThan(0);
-    }
-  });
-
-  it("all tools have unique names", () => {
-    const names = TOOLS.map((t) => t.name);
-    expect(new Set(names).size).toBe(names.length);
-  });
-});
-
-describe("wrapExecute", () => {
-  it("returns content array on success", async () => {
-    // Use real Exa endpoint — web_search should work
-    const tool = TOOLS.find((t) => t.name === "exa_web_search")!;
-    const result = await tool.execute("test-id", { query: "OpenAI", numResults: 1 });
-
-    expect(result.isError).toBeUndefined();
-    expect(result.content).toHaveLength(1);
-    expect(result.content[0].type).toBe("text");
-    expect(result.content[0].text.length).toBeGreaterThan(0);
-  });
-
-  it("wraps errors with isError flag", async () => {
-    // Call with a tool that will fail — pass invalid params to trigger Exa error
-    const tool = TOOLS.find((t) => t.name === "exa_people_search")!;
-    // Empty query should cause an error from Exa
-    const result = await tool.execute("test-id", { query: "" });
-
-    // Either succeeds or fails gracefully — both paths are valid
-    if (result.isError) {
-      expect(result.content[0].text).toMatch(/^Error:/);
-    } else {
-      expect(result.content[0].type).toBe("text");
-    }
-  });
-});

package/src/index.ts

@@ -1,210 +0,0 @@
-/**
- * OpenClaw Exa Search Plugin
- *
- * Registers 6 tools: web_search, code_search, company_research,
- * twitter_search, people_search, financial_report_search
- */
-
-import {
-  webSearch,
-  codeSearch,
-  companyResearch,
-  twitterSearch,
-  peopleSearch,
-  financialSearch,
-} from "./exa-mcp-client";
-
-interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: Record<string, unknown>;
-  execute: (id: string, params: Record<string, unknown>) => Promise<{
-    content: Array<{ type: string; text: string }>;
-    isError?: boolean;
-  }>;
-}
-
-interface PluginAPI {
-  registerTool: (tool: ToolDefinition) => void;
-}
-
-function wrapExecute(
-  fn: (params: any) => Promise<string>
-): ToolDefinition["execute"] {
-  return async (_id: string, params: Record<string, unknown>) => {
-    try {
-      const result = await fn(params);
-      return { content: [{ type: "text", text: result }] };
-    } catch (error: unknown) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        content: [{ type: "text", text: `Error: ${message}` }],
-        isError: true,
-      };
-    }
-  };
-}
-
-const TOOLS: ToolDefinition[] = [
-  {
-    name: "exa_web_search",
-    description:
-      "Search the web using Exa AI neural search. Find current information, news, facts, or answer questions about any topic. Returns clean, formatted content ready for LLM use.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Web search query" },
-        numResults: {
-          type: "number",
-          description: "Number of search results to return (default: 8)",
-        },
-        type: {
-          type: "string",
-          enum: ["auto", "fast", "deep"],
-          description:
-            "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive research",
-        },
-        livecrawl: {
-          type: "string",
-          enum: ["fallback", "preferred"],
-          description:
-            "Live crawl mode - 'fallback': use live crawling as backup if cached unavailable, 'preferred': prioritize live crawling",
-        },
-      },
-      required: ["query"],
-    },
-    execute: wrapExecute(webSearch),
-  },
-  {
-    name: "exa_code_search",
-    description:
-      "Find code examples, documentation, and programming solutions from GitHub, Stack Overflow, and official docs. Useful for API usage, library examples, code snippets, and debugging help.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description:
-            "Search query for code context - e.g., 'React useState hook examples', 'Python pandas dataframe filtering'",
-        },
-        tokensNum: {
-          type: "number",
-          description:
-            "Number of tokens to return (1000-50000). Lower for focused queries, higher for comprehensive docs (default: 5000)",
-        },
-      },
-      required: ["query"],
-    },
-    execute: wrapExecute(codeSearch),
-  },
-  {
-    name: "exa_company_research",
-    description:
-      "Research any company to get business information, news, and insights. Returns information from trusted business sources about products, services, recent news, or industry position.",
-    parameters: {
-      type: "object",
-      properties: {
-        companyName: {
-          type: "string",
-          description: "Name of the company to research",
-        },
-        numResults: {
-          type: "number",
-          description: "Number of search results to return (default: 5)",
-        },
-      },
-      required: ["companyName"],
-    },
-    execute: wrapExecute(companyResearch),
-  },
-  {
-    name: "exa_twitter_search",
-    description:
-      "Search Twitter/X posts. Find tweets, discussions, and social commentary on any topic. Useful for tracking public sentiment, announcements, and trending discussions.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "Search query for Twitter/X posts",
-        },
-        numResults: {
-          type: "number",
-          description: "Number of tweets to return (default: 10)",
-        },
-        startPublishedDate: {
-          type: "string",
-          description:
-            "Filter tweets published after this date (ISO 8601 format, e.g., '2024-01-01T00:00:00.000Z')",
-        },
-        endPublishedDate: {
-          type: "string",
-          description:
-            "Filter tweets published before this date (ISO 8601 format)",
-        },
-      },
-      required: ["query"],
-    },
-    execute: wrapExecute(twitterSearch),
-  },
-  {
-    name: "exa_people_search",
-    description:
-      "Find people and their professional profiles. Search for individuals by name, role, company, or expertise. Returns public LinkedIn and professional profile data.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description:
-            "Search query for people - e.g., 'CTO at Anthropic', 'machine learning researchers Stanford'",
-        },
-        numResults: {
-          type: "number",
-          description: "Number of results to return (default: 5)",
-        },
-      },
-      required: ["query"],
-    },
-    execute: wrapExecute(peopleSearch),
-  },
-  {
-    name: "exa_financial_report_search",
-    description:
-      "Search financial reports — 10-K, 10-Q, annual reports, quarterly earnings, and SEC filings for public companies.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description:
-            "Search query for financial reports - e.g., 'Apple 2024 Q4 earnings', 'Tesla annual report 2024'",
-        },
-        numResults: {
-          type: "number",
-          description: "Number of results to return (default: 10)",
-        },
-        startPublishedDate: {
-          type: "string",
-          description:
-            "Filter reports published after this date (ISO 8601 format)",
-        },
-        endPublishedDate: {
-          type: "string",
-          description:
-            "Filter reports published before this date (ISO 8601 format)",
-        },
-      },
-      required: ["query"],
-    },
-    execute: wrapExecute(financialSearch),
-  },
-];
-
-export default function (api: PluginAPI) {
-  for (const tool of TOOLS) {
-    api.registerTool(tool);
-  }
-}
-
-export { TOOLS };

package/src/integration.spec.ts

@@ -1,60 +0,0 @@
-/**
- * Integration tests — hits real Exa MCP endpoint
- * Run with: npm run test:integration
- */
-
-import { describe, it, expect } from "vitest";
-import {
-  webSearch,
-  codeSearch,
-  companyResearch,
-  twitterSearch,
-  peopleSearch,
-  financialSearch,
-} from "./exa-mcp-client";
-
-const TIMEOUT = 30_000;
-
-describe("integration: Exa MCP endpoint", () => {
-  it("exa_web_search", async () => {
-    const result = await webSearch({ query: "OpenAI latest news", numResults: 3 });
-    expect(result).toBeTruthy();
-    expect(result.length).toBeGreaterThan(50);
-    console.log("[web_search] ✅", result.slice(0, 200), "...");
-  }, TIMEOUT);
-
-  it("exa_code_search", async () => {
-    const result = await codeSearch({ query: "React useState hook examples", tokensNum: 2000 });
-    expect(result).toBeTruthy();
-    expect(result.length).toBeGreaterThan(50);
-    console.log("[code_search] ✅", result.slice(0, 200), "...");
-  }, TIMEOUT);
-
-  it("exa_company_research", async () => {
-    const result = await companyResearch({ companyName: "Anthropic", numResults: 3 });
-    expect(result).toBeTruthy();
-    expect(result.length).toBeGreaterThan(50);
-    console.log("[company_research] ✅", result.slice(0, 200), "...");
-  }, TIMEOUT);
-
-  it("exa_twitter_search", async () => {
-    const result = await twitterSearch({ query: "AI agents", numResults: 5 });
-    expect(result).toBeTruthy();
-    expect(result.length).toBeGreaterThan(50);
-    console.log("[twitter_search] ✅", result.slice(0, 200), "...");
-  }, TIMEOUT);
-
-  it("exa_people_search", async () => {
-    const result = await peopleSearch({ query: "CTO at Anthropic", numResults: 3 });
-    expect(result).toBeTruthy();
-    expect(result.length).toBeGreaterThan(50);
-    console.log("[people_search] ✅", result.slice(0, 200), "...");
-  }, TIMEOUT);
-
-  it("exa_financial_search", async () => {
-    const result = await financialSearch({ query: "Apple 2024 annual report", numResults: 3 });
-    expect(result).toBeTruthy();
-    expect(result.length).toBeGreaterThan(50);
-    console.log("[financial_search] ✅", result.slice(0, 200), "...");
-  }, TIMEOUT);
-});