@wipcomputer/openclaw-tavily 1.0.2

package/.worktrees/cc-mini/v102-issue-ref/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@wipcomputer/openclaw-tavily",
+  "version": "1.0.1",
+  "description": "Tavily AI search and content extraction plugin for OpenClaw with 1Password integration",
+  "type": "module",
+  "main": "dist/index.js",
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "tavily",
+    "web-search",
+    "content-extraction",
+    "1password"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "author": "Lēsa <lesaai@icloud.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.2.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@1password/sdk": "^0.3.1"
+  }
+}

package/.worktrees/cc-mini/v102-issue-ref/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/.worktrees/cc-mini/v102-issue-ref/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/**/*"]
+}

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 1.0.2 (2026-07-20)
+
+# Tavily v1.0.2
+
+The WIP Tavily extension now declares its built runtime entry, two runtime tools, and explicit startup activation. OpenClaw 2026.6.11 can register the search and extraction tools when this installed extension is selected over the bundled Tavily plugin.
+
+This release also adds the complete MIT licensing scaffold required by the release pipeline. The package metadata, repository license, license-guard configuration, README, and contributor agreement now agree on the current licensing terms.
+
+Closes #5.

package/CLA.md

@@ -0,0 +1,17 @@
+###### WIP Computer
+
+# Contributor License Agreement
+
+By submitting a pull request to this repository, you agree to the following:
+
+1. **You grant WIP Computer, Inc. a perpetual, worldwide, non-exclusive, royalty-free, irrevocable license** to use, reproduce, modify, distribute, sublicense, and otherwise exploit your contribution under any license, including commercial licenses.
+
+2. **You retain copyright** to your contribution. This agreement does not transfer ownership. You can use your own code however you want.
+
+3. **You confirm** that your contribution is your original work, or that you have the right to submit it under these terms.
+
+4. **You understand** that your contribution may be used in both open source and commercial versions of this software.
+
+This is standard open source governance. The agreement keeps contributions usable by WIP Computer while contributors retain ownership of their work.
+
+If you have questions, open an issue or reach out.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WIP Computer, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# openclaw-tavily
+
+Tavily AI search and content extraction plugin for OpenClaw.
+
+## What It Does
+
+Adds two tools to OpenClaw:
+
+- **`tavily_search`** — AI-powered web search with answer summaries
+- **`tavily_extract`** — Clean content extraction from URLs
+
+Both tools use 1Password for secure API key storage (no plaintext keys in config).
+
+## Features
+
+- **Search modes**: `basic` (fast, 1 credit) or `advanced` (thorough, 2 credits)
+- **Topic filtering**: `general`, `news`, or `finance`
+- **Domain control**: Include or exclude specific domains
+- **Answer summaries**: AI-generated answer from search results
+- **Multi-URL extraction**: Extract clean content from multiple URLs in one call
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+## Set Up Tavily
+
+1. **Store Tavily API key in 1Password:**
+   ```bash
+   op item create \
+     --category="API Credential" \
+     --title="Tavily API" \
+     --vault="Agent Secrets" \
+     'api key[password]=tvly-YOUR_KEY_HERE'
+   ```
+
+2. **Add to OpenClaw:**
+   Copy dist/ to `~/.openclaw/extensions/openclaw-tavily/`
+
+3. **Enable in openclaw.json:**
+   ```json
+   {
+     "plugins": {
+       "entries": {
+         "openclaw-tavily": {
+           "enabled": true
+         }
+       }
+     }
+   }
+   ```
+
+## Usage
+
+### Search
+```typescript
+await tavily_search({
+  query: "latest AI regulation news",
+  search_depth: "advanced",
+  topic: "news",
+  max_results: 10
+})
+```
+
+### Extract
+```typescript
+await tavily_extract({
+  urls: [
+    "https://example.com/article1",
+    "https://example.com/article2"
+  ]
+})
+```
+
+## How It Works
+
+- **1Password SDK**: Secure credential resolution via `op://Agent Secrets/Tavily API/api key`
+- **Tavily API**: Search at `https://api.tavily.com/search`, extract at `/extract`
+- **MCP-compatible**: Returns tool results in MCP format
+
+## Why 1Password Integration?
+
+No more API keys in config files. The Tavily API key is stored in 1Password's "Agent Secrets" vault and resolved at runtime via the 1Password SDK.
+
+## Status
+
+**Active/Deployed** — Running in Lēsa's OpenClaw environment.
+
+## Author
+
+Built by Lēsa / WIP.computer 🏴‍☠️
+
+## License
+
+MIT. Built by Parker Todd Brooks, Lēsa, Claude Code, and Codex.

package/_trash/RELEASE-NOTES-v1-0-2.md

@@ -0,0 +1,7 @@
+# Tavily v1.0.2
+
+The WIP Tavily extension now declares its built runtime entry, two runtime tools, and explicit startup activation. OpenClaw 2026.6.11 can register the search and extraction tools when this installed extension is selected over the bundled Tavily plugin.
+
+This release also adds the complete MIT licensing scaffold required by the release pipeline. The package metadata, repository license, license-guard configuration, README, and contributor agreement now agree on the current licensing terms.
+
+Closes #5.

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+declare const tavilyPlugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        type: "object";
+        additionalProperties: boolean;
+        properties: {
+            vault: {
+                type: "string";
+            };
+            tokenPath: {
+                type: "string";
+            };
+        };
+    };
+    register(api: any): void;
+};
+export default tavilyPlugin;