@wipcomputer/openclaw-tavily 1.0.2

package/src/index.ts

@@ -0,0 +1,374 @@
+import { readFileSync, existsSync } from "node:fs";
+import { createClient, type Client } from "@1password/sdk";
+
+const TAVILY_SEARCH_URL = "https://api.tavily.com/search";
+const TAVILY_EXTRACT_URL = "https://api.tavily.com/extract";
+
+const DEFAULT_VAULT = "Agent Secrets";
+const DEFAULT_TOKEN_PATH = `${process.env.HOME}/.openclaw/secrets/op-sa-token`;
+const TAVILY_ITEM_NAME = "Tavily API";
+const TAVILY_FIELD_NAME = "api key";
+
+// ── 1Password SDK client (lazy singleton) ───────────────────────────
+
+let _client: Client | null = null;
+
+async function getClient(tokenPath: string): Promise<Client> {
+  if (_client) return _client;
+
+  if (!existsSync(tokenPath)) {
+    throw new Error(`1Password token not found at ${tokenPath}`);
+  }
+
+  const token = readFileSync(tokenPath, "utf-8").trim();
+  _client = await createClient({
+    auth: token,
+    integrationName: "OpenClaw-Tavily",
+    integrationVersion: "1.0.0",
+  });
+  return _client;
+}
+
+async function resolveFromOnePassword(
+  tokenPath: string,
+  vault: string,
+  item: string,
+  field: string,
+): Promise<string> {
+  const client = await getClient(tokenPath);
+  return await client.secrets.resolve(`op://${vault}/${item}/${field}`);
+}
+
+// ── MCP-style tool result helper ────────────────────────────────────
+
+function toolResult(text: string, isError = false) {
+  return {
+    content: [{ type: "text" as const, text }],
+    details: undefined as unknown,
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+// ── Tavily API calls ────────────────────────────────────────────────
+
+async function tavilySearch(apiKey: string, params: {
+  query: string;
+  search_depth?: string;
+  topic?: string;
+  max_results?: number;
+  include_answer?: boolean;
+  include_raw_content?: boolean;
+  include_domains?: string[];
+  exclude_domains?: string[];
+}): Promise<any> {
+  const body = {
+    query: params.query,
+    search_depth: params.search_depth || "basic",
+    topic: params.topic || "general",
+    max_results: params.max_results || 5,
+    include_answer: params.include_answer !== false,
+    include_raw_content: params.include_raw_content || false,
+    include_domains: params.include_domains || [],
+    exclude_domains: params.exclude_domains || [],
+  };
+
+  const response = await fetch(TAVILY_SEARCH_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Tavily search failed (${response.status}): ${text}`);
+  }
+
+  return response.json();
+}
+
+async function tavilyExtract(apiKey: string, urls: string[]): Promise<any> {
+  const response = await fetch(TAVILY_EXTRACT_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({ urls }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Tavily extract failed (${response.status}): ${text}`);
+  }
+
+  return response.json();
+}
+
+// ── OpenClaw Plugin ─────────────────────────────────────────────────
+
+const tavilyPlugin = {
+  id: "tavily",
+  name: "Tavily Search",
+  description: "Web search and content extraction via Tavily API, with 1Password key resolution",
+
+  configSchema: {
+    type: "object" as const,
+    additionalProperties: false,
+    properties: {
+      vault: { type: "string" as const },
+      tokenPath: { type: "string" as const },
+    },
+  },
+
+  register(api: any) {
+    const pluginConfig = api.pluginConfig ||
+      (api.config as any)?.plugins?.entries?.tavily?.config || {};
+    const vault = pluginConfig.vault || DEFAULT_VAULT;
+    const tokenPath = pluginConfig.tokenPath || DEFAULT_TOKEN_PATH;
+
+    let cachedKey: string | null = null;
+
+    async function getApiKey(): Promise<string> {
+      if (cachedKey) return cachedKey;
+
+      // 1. Check environment variable (may be set by op-secrets service)
+      if (process.env.TAVILY_API_KEY) {
+        cachedKey = process.env.TAVILY_API_KEY;
+        return cachedKey;
+      }
+
+      // 2. Resolve from 1Password SDK
+      try {
+        const key = await resolveFromOnePassword(
+          tokenPath, vault, TAVILY_ITEM_NAME, TAVILY_FIELD_NAME
+        );
+        if (key) {
+          cachedKey = key;
+          process.env.TAVILY_API_KEY = key; // Set for skill access too
+          return cachedKey;
+        }
+      } catch (err: any) {
+        throw new Error(
+          `Tavily API key not found. Store as "${TAVILY_ITEM_NAME}" in ` +
+          `1Password vault "${vault}", or set TAVILY_API_KEY env var. ` +
+          `Error: ${err.message}`
+        );
+      }
+
+      throw new Error("Tavily API key not found");
+    }
+
+    // ── Tool: tavily_search ───────────────────────────────────────
+
+    api.registerTool(
+      {
+        name: "tavily_search",
+        label: "Tavily Web Search",
+        description:
+          "Search the web using Tavily AI search. Returns titles, URLs, content " +
+          "snippets, and an AI-generated answer summary. Use for research, " +
+          "fact-checking, current events, regulations, and finding specific information.",
+        parameters: {
+          type: "object",
+          required: ["query"],
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query string",
+            },
+            search_depth: {
+              type: "string",
+              enum: ["basic", "advanced"],
+              description: "basic (faster, 1 credit) or advanced (thorough, 2 credits). Default: basic",
+            },
+            topic: {
+              type: "string",
+              enum: ["general", "news", "finance"],
+              description: "Topic category. Default: general",
+            },
+            max_results: {
+              type: "number",
+              description: "Max results (1-20). Default: 5",
+            },
+            include_answer: {
+              type: "boolean",
+              description: "Include AI answer summary. Default: true",
+            },
+            include_domains: {
+              type: "array",
+              items: { type: "string" },
+              description: "Only include results from these domains",
+            },
+            exclude_domains: {
+              type: "array",
+              items: { type: "string" },
+              description: "Exclude results from these domains",
+            },
+          },
+        },
+        async execute(_id: string, params: any) {
+          try {
+            const apiKey = await getApiKey();
+            const result = await tavilySearch(apiKey, params);
+
+            let output = "";
+            if (result.answer) {
+              output += `**Answer:** ${result.answer}\n\n`;
+            }
+            if (result.results?.length > 0) {
+              output += `**Results (${result.results.length}):**\n\n`;
+              for (const r of result.results) {
+                const snippet = r.content?.slice(0, 300) || "(no snippet)";
+                const ellipsis = r.content?.length > 300 ? "..." : "";
+                output += `- **${r.title}**\n  ${r.url}\n  ${snippet}${ellipsis}\n  Score: ${r.score?.toFixed(3) || "n/a"}\n\n`;
+              }
+            }
+            output += `_Response time: ${result.response_time}s | Credits: ${result.usage?.credits || "?"}_`;
+
+            return toolResult(output);
+          } catch (err: any) {
+            return toolResult(`Tavily search error: ${err.message}`, true);
+          }
+        },
+      } as any,
+      { optional: true },
+    );
+
+    // ── Tool: tavily_extract ──────────────────────────────────────
+
+    api.registerTool(
+      {
+        name: "tavily_extract",
+        label: "Tavily Content Extract",
+        description:
+          "Extract clean content from one or more URLs using Tavily. " +
+          "Returns raw text content of web pages. Better than web_fetch for many sites.",
+        parameters: {
+          type: "object",
+          required: ["urls"],
+          properties: {
+            urls: {
+              type: "array",
+              items: { type: "string" },
+              description: "URLs to extract content from",
+            },
+          },
+        },
+        async execute(_id: string, params: { urls: string[] }) {
+          try {
+            const apiKey = await getApiKey();
+            const result = await tavilyExtract(apiKey, params.urls);
+
+            let output = "";
+            if (result.results?.length > 0) {
+              for (const r of result.results) {
+                output += `## ${r.url}\n\n`;
+                const content = r.raw_content?.slice(0, 5000) || "(no content)";
+                output += content;
+                if (r.raw_content?.length > 5000) output += "\n...(truncated)";
+                output += "\n\n---\n\n";
+              }
+            }
+            if (result.failed_results?.length > 0) {
+              output += `**Failed:** ${result.failed_results.map((f: any) => f.url).join(", ")}\n`;
+            }
+            output += `_Response time: ${result.response_time}s | Credits: ${result.usage?.credits || "?"}_`;
+
+            return toolResult(output);
+          } catch (err: any) {
+            return toolResult(`Tavily extract error: ${err.message}`, true);
+          }
+        },
+      } as any,
+      { optional: true },
+    );
+
+    // ── Service: resolve key at startup ───────────────────────────
+
+    api.registerService?.({
+      id: "tavily-key-resolver",
+      async start(ctx: any) {
+        if (process.env.TAVILY_API_KEY) {
+          ctx.logger.info("tavily: TAVILY_API_KEY already set in environment");
+          return;
+        }
+        try {
+          const key = await resolveFromOnePassword(
+            tokenPath, vault, TAVILY_ITEM_NAME, TAVILY_FIELD_NAME
+          );
+          if (key) {
+            process.env.TAVILY_API_KEY = key;
+            cachedKey = key;
+            ctx.logger.info("tavily: set TAVILY_API_KEY from 1Password");
+          }
+        } catch (err: any) {
+          ctx.logger.warn(`tavily: key not found in 1Password (${err.message}). Add "${TAVILY_ITEM_NAME}" to vault "${vault}".`);
+        }
+      },
+    });
+
+    // ── CLI commands ─────────────────────────────────────────────
+
+    api.registerCli?.(
+      ({ program }: any) => {
+        const cmd = program
+          .command("tavily")
+          .description("Tavily search plugin");
+
+        cmd
+          .command("test")
+          .description("Test Tavily API connectivity")
+          .action(async () => {
+            try {
+              const key = await getApiKey();
+              console.log("Tavily API key resolved. Testing search...");
+              const result = await tavilySearch(key, {
+                query: "test",
+                max_results: 1,
+                include_answer: false,
+              });
+              console.log(`Tavily connection OK — ${result.results?.length || 0} result(s), ${result.response_time}s`);
+            } catch (err: any) {
+              console.error("Tavily test FAILED:", err.message);
+              process.exit(1);
+            }
+          });
+
+        cmd
+          .command("search")
+          .description("Quick search from CLI")
+          .argument("<query>", "Search query")
+          .option("-n, --max-results <n>", "Max results", "5")
+          .action(async (query: string, opts: { maxResults: string }) => {
+            try {
+              const key = await getApiKey();
+              const result = await tavilySearch(key, {
+                query,
+                max_results: parseInt(opts.maxResults),
+                include_answer: true,
+              });
+              if (result.answer) {
+                console.log(`\nAnswer: ${result.answer}\n`);
+              }
+              for (const r of (result.results || [])) {
+                console.log(`- ${r.title}`);
+                console.log(`  ${r.url}`);
+                console.log(`  ${r.content?.slice(0, 200) || ""}\n`);
+              }
+            } catch (err: any) {
+              console.error("Search failed:", err.message);
+              process.exit(1);
+            }
+          });
+      },
+      { commands: ["tavily"] },
+    );
+
+    api.logger.info(`tavily plugin registered (vault: ${vault}, key: ${process.env.TAVILY_API_KEY ? "env" : "1password"})`);
+  },
+};
+
+export default tavilyPlugin;

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022", "DOM"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}