opencode-websearch 0.1.0

package/README.md

@@ -0,0 +1,84 @@
+# opencode-websearch
+
+Web search plugin for [OpenCode](https://opencode.ai), powered by Anthropic's server-side `web_search` API. A port of the Claude Code WebSearch tool to OpenCode.
+
+## Install
+
+Add the plugin to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-websearch"]
+}
+```
+
+OpenCode will install it automatically at startup.
+
+## Configuration
+
+The plugin needs an Anthropic API key. It resolves credentials in this order:
+
+1. **opencode.json** -- looks for an `@ai-sdk/anthropic` provider in your project or global config
+2. **Environment variable** -- falls back to `ANTHROPIC_API_KEY`
+
+### Option 1: opencode.json provider (recommended)
+
+If you already have an Anthropic provider configured, the plugin will use it automatically:
+
+```json
+{
+  "provider": {
+    "anthropic": {
+      "npm": "@ai-sdk/anthropic",
+      "options": {
+        "apiKey": "{env:ANTHROPIC_API_KEY}"
+      },
+      "models": {
+        "claude-sonnet-4-5": { "name": "Claude Sonnet 4.5" }
+      }
+    }
+  }
+}
+```
+
+The model used for search is the first model listed in the provider config.
+
+### Option 2: environment variable
+
+```sh
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+When using the env var fallback, `claude-sonnet-4-5` is used as the default model.
+
+## Usage
+
+Once configured, the `web-search` tool is available to the AI agent. It accepts:
+
+| Argument | Type | Required | Description |
+|---|---|---|---|
+| `query` | `string` | Yes | The search query |
+| `allowed_domains` | `string[]` | No | Restrict results to these domains |
+| `blocked_domains` | `string[]` | No | Exclude results from these domains |
+| `max_uses` | `number` (1-10) | No | Max searches per invocation (default: 5) |
+
+You cannot specify both `allowed_domains` and `blocked_domains` at the same time.
+
+Results are returned as formatted markdown with source links.
+
+## Development
+
+```sh
+# Install dependencies
+bun install
+
+# Type check
+bun run typecheck
+
+# Build
+bun run build
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+declare const _default: () => Promise<{
+    tool: {
+        "web-search": {
+            description: string;
+            args: {
+                allowed_domains: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                blocked_domains: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                max_uses: import("zod").ZodOptional<import("zod").ZodNumber>;
+                query: import("zod").ZodString;
+            };
+            execute(args: {
+                query: string;
+                allowed_domains?: string[] | undefined;
+                blocked_domains?: string[] | undefined;
+                max_uses?: number | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
+    };
+}>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAobA,wBAoDqB"}

package/dist/index.js

@@ -0,0 +1,315 @@
+// src/index.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { tool } from "@opencode-ai/plugin";
+import Anthropic, { APIError } from "@anthropic-ai/sdk";
+var DEFAULT_MODEL = "claude-sonnet-4-5";
+var MONTH_OFFSET = 1;
+var PAD_LENGTH = 2;
+var ENV_VAR_CAPTURE_GROUP = 1;
+var FIRST_MODEL_INDEX = 0;
+var EMPTY_LENGTH = 0;
+var MIN_QUERY_LENGTH = 2;
+var MIN_SEARCH_USES = 1;
+var MAX_SEARCH_USES = 10;
+var DEFAULT_SEARCH_USES = 5;
+var MAX_RESPONSE_TOKENS = 16000;
+var getTodayDate = () => {
+  const now = new Date;
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + MONTH_OFFSET).padStart(PAD_LENGTH, "0");
+  const day = String(now.getDate()).padStart(PAD_LENGTH, "0");
+  return `${year}-${month}-${day}`;
+};
+var resolveEnvVar = (value) => {
+  const match = value.match(/^\{env:(\w+)\}$/);
+  if (match?.[ENV_VAR_CAPTURE_GROUP]) {
+    return process.env[match[ENV_VAR_CAPTURE_GROUP]] ?? "";
+  }
+  return value;
+};
+var normalizeBaseURL = (url) => url.replace(/\/v1\/?$/, "");
+var CONFIG_PATHS = [
+  join(process.cwd(), "opencode.json"),
+  join(process.cwd(), ".opencode", "opencode.json"),
+  join(homedir(), ".config", "opencode", "opencode.json")
+];
+var parseConfigFile = (configPath) => {
+  try {
+    return JSON.parse(readFileSync(configPath, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return `Failed to parse ${configPath}: ${error.message}`;
+    }
+    return `Failed to parse ${configPath}: ${String(error)}`;
+  }
+};
+var resolveProviderApiKey = (ctx, rawApiKey) => {
+  const apiKey = resolveEnvVar(rawApiKey);
+  if (apiKey) {
+    return apiKey;
+  }
+  const envMatch = rawApiKey.match(/^\{env:(\w+)\}$/);
+  if (envMatch) {
+    ctx.errors.push(`${ctx.configPath}: Environment variable ${envMatch[ENV_VAR_CAPTURE_GROUP]} is not set`);
+  } else {
+    ctx.errors.push(`${ctx.configPath}: Provider "${ctx.providerName}" has empty apiKey`);
+  }
+  return;
+};
+var resolveModelName = (provider) => {
+  if (!provider.models) {
+    return DEFAULT_MODEL;
+  }
+  const models = Object.keys(provider.models);
+  return models[FIRST_MODEL_INDEX] ?? DEFAULT_MODEL;
+};
+var resolveBaseURL = (provider) => {
+  if (!provider.options?.baseURL) {
+    return;
+  }
+  return normalizeBaseURL(resolveEnvVar(provider.options.baseURL));
+};
+var resolveProviderConfig = (ctx, provider) => {
+  if (provider.npm !== "@ai-sdk/anthropic") {
+    return;
+  }
+  if (!provider.options?.apiKey) {
+    ctx.errors.push(`${ctx.configPath}: Provider "${ctx.providerName}" has no apiKey configured`);
+    return;
+  }
+  const apiKey = resolveProviderApiKey(ctx, provider.options.apiKey);
+  if (!apiKey) {
+    return;
+  }
+  return {
+    apiKey,
+    baseURL: resolveBaseURL(provider),
+    model: resolveModelName(provider)
+  };
+};
+var scanProviders = (configPath, providers, errors) => {
+  for (const [providerName, provider] of Object.entries(providers)) {
+    const ctx = { configPath, errors, providerName };
+    const resolved = resolveProviderConfig(ctx, provider);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return;
+};
+var scanConfigFile = (configPath, errors) => {
+  if (!existsSync(configPath)) {
+    return;
+  }
+  const parsed = parseConfigFile(configPath);
+  if (typeof parsed === "string") {
+    errors.push(parsed);
+    return;
+  }
+  if (!parsed.provider) {
+    errors.push(`${configPath}: No "provider" field found`);
+    return;
+  }
+  return scanProviders(configPath, parsed.provider, errors);
+};
+var scanAllConfigFiles = (errors) => {
+  for (const configPath of CONFIG_PATHS) {
+    const resolved = scanConfigFile(configPath, errors);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return;
+};
+var getEnvFallback = () => {
+  const envApiKey = process.env.ANTHROPIC_API_KEY;
+  if (envApiKey) {
+    return {
+      config: {
+        apiKey: envApiKey,
+        model: DEFAULT_MODEL
+      }
+    };
+  }
+  return;
+};
+var getAnthropicConfig = () => {
+  const errors = [];
+  const fromConfig = scanAllConfigFiles(errors);
+  if (fromConfig) {
+    return { config: fromConfig };
+  }
+  const fromEnv = getEnvFallback();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  if (errors.length > EMPTY_LENGTH) {
+    return { config: null, error: errors.join(`
+`) };
+  }
+  return { config: null };
+};
+var formatSearchResult = (result) => {
+  if (result.page_age) {
+    return `- [${result.title}](${result.url}) (Updated: ${result.page_age})`;
+  }
+  return `- [${result.title}](${result.url})`;
+};
+var processSearchToolResult = (block, results) => {
+  if (Array.isArray(block.content)) {
+    const searchResults = block.content;
+    if (searchResults.length === EMPTY_LENGTH) {
+      results.push("No results found.");
+    } else {
+      results.push(`
+Found ${searchResults.length} results:
+`);
+      for (const result of searchResults) {
+        results.push(formatSearchResult(result));
+      }
+    }
+  } else if (block.content?.type === "web_search_tool_result_error") {
+    results.push(`Search error: ${block.content.error_code}`);
+  }
+};
+var processBlock = (block, results) => {
+  if (block.type === "server_tool_use" && block.name === "web_search") {
+    results.push(`Search query: "${block.input.query}"`);
+    return;
+  }
+  if (block.type === "web_search_tool_result") {
+    processSearchToolResult(block, results);
+    return;
+  }
+  if (block.type === "text" && block.text) {
+    results.push(`
+${block.text}`);
+  }
+};
+var buildWebSearchTool = (args) => {
+  const searchTool = {
+    max_uses: args.max_uses ?? DEFAULT_SEARCH_USES,
+    name: "web_search",
+    type: "web_search_20250305"
+  };
+  if (args.allowed_domains?.length) {
+    searchTool.allowed_domains = args.allowed_domains;
+  }
+  if (args.blocked_domains?.length) {
+    searchTool.blocked_domains = args.blocked_domains;
+  }
+  return searchTool;
+};
+var formatConfigError = (error) => {
+  let hint = "";
+  if (error) {
+    hint = `
+
+${error}`;
+  }
+  return `Error: web-search requires an Anthropic API key.
+
+Set the ANTHROPIC_API_KEY environment variable, or add an Anthropic provider to your opencode.json:
+
+{
+  "provider": {
+    "anthropic": {
+      "npm": "@ai-sdk/anthropic",
+      "options": {
+        "apiKey": "{env:ANTHROPIC_API_KEY}"
+      },
+      "models": {
+        "claude-sonnet-4-5": { "name": "Claude Sonnet 4.5" }
+      }
+    }
+  }
+}${hint}`;
+};
+var formatErrorMessage = (error) => {
+  if (error instanceof APIError) {
+    return `Anthropic API error: ${error.message} (status: ${error.status})`;
+  }
+  if (error instanceof Error) {
+    return `Error performing web search: ${error.message}`;
+  }
+  return `Error performing web search: ${String(error)}`;
+};
+var createAnthropicClient = (config) => {
+  const options = {
+    apiKey: config.apiKey
+  };
+  if (config.baseURL) {
+    options.baseURL = config.baseURL;
+  }
+  return new Anthropic(options);
+};
+var appendUsageInfo = (usage, results) => {
+  if (usage.server_tool_use?.web_search_requests) {
+    results.push(`
+---
+Searches performed: ${usage.server_tool_use.web_search_requests}`);
+  }
+};
+var executeSearch = async (config, args) => {
+  const client = createAnthropicClient(config);
+  const webSearchTool = buildWebSearchTool(args);
+  const response = await client.messages.create({
+    max_tokens: MAX_RESPONSE_TOKENS,
+    messages: [
+      {
+        content: `Perform a web search for: ${args.query}`,
+        role: "user"
+      }
+    ],
+    model: config.model,
+    tools: [webSearchTool]
+  });
+  const results = [];
+  const content = response.content;
+  for (const block of content) {
+    processBlock(block, results);
+  }
+  appendUsageInfo(response.usage, results);
+  return results.join(`
+`) || "No results returned from web search.";
+};
+var src_default = async () => ({
+  tool: {
+    "web-search": tool({
+      args: {
+        allowed_domains: tool.schema.array(tool.schema.string()).optional().describe("Only include results from these domains"),
+        blocked_domains: tool.schema.array(tool.schema.string()).optional().describe("Exclude results from these domains"),
+        max_uses: tool.schema.number().min(MIN_SEARCH_USES).max(MAX_SEARCH_USES).optional().describe("Maximum number of searches to perform (default: 5)"),
+        query: tool.schema.string().min(MIN_QUERY_LENGTH).describe("The search query to execute")
+      },
+      description: `Search the web using Anthropic's server-side web_search API.
+
+- Provides up-to-date information for current events and recent data
+- Returns search results with links as markdown hyperlinks
+- Use this for accessing information beyond the knowledge cutoff
+
+CRITICAL: After answering, you MUST include a "Sources:" section with URLs as markdown hyperlinks.
+
+Today's date: ${getTodayDate()}. Use the current year when searching for recent information.`,
+      async execute(args) {
+        const { config, error } = getAnthropicConfig();
+        if (!config) {
+          return formatConfigError(error);
+        }
+        if (args.allowed_domains && args.blocked_domains) {
+          return "Error: Cannot specify both allowed_domains and blocked_domains.";
+        }
+        try {
+          return await executeSearch(config, args);
+        } catch (error2) {
+          return formatErrorMessage(error2);
+        }
+      }
+    })
+  }
+});
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "opencode-websearch",
+  "version": "0.1.0",
+  "description": "Claude Code's WebSearch tool ported to OpenCode",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --packages external && bun run build:types",
+    "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist",
+    "dev": "bun run --watch src/index.ts",
+    "lint": "oxlint --tsconfig tsconfig.json src/",
+    "typecheck": "tsc --noEmit",
+    "check": "bun run lint && bun run typecheck",
+    "prepublishOnly": "bun run check && bun run build"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "web-search",
+    "anthropic",
+    "ai"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.1.65",
+    "@types/bun": "latest",
+    "oxlint": "^1.47.0",
+    "typescript": "^5.8.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  }
+}