@oh-my-pi/anthropic-websearch 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# @oh-my-pi/anthropic-websearch
+
+Claude web search tool for [pi](https://github.com/badlogic/pi-mono).
+
+Uses Anthropic's built-in `web_search_20250305` tool to search the web and synthesize answers with citations.
+
+## Installation
+
+```bash
+omp install @oh-my-pi/anthropic-websearch
+```
+
+## Authentication
+
+The plugin checks for credentials in this order:
+
+1. **Explicit override**: `ANTHROPIC_SEARCH_API_KEY` / `ANTHROPIC_SEARCH_BASE_URL`
+2. **models.json**: Provider with `api: "anthropic-messages"` in `~/.pi/agent/models.json`
+3. **OAuth**: Anthropic OAuth credentials in `~/.pi/agent/auth.json`
+4. **Fallback**: `ANTHROPIC_API_KEY` / `ANTHROPIC_BASE_URL`
+
+This ordering prevents accidentally charging your console account if you have a proxy or OAuth set up.
+
+### Example: Using a proxy
+
+If your `~/.pi/agent/models.json` has:
+
+```json
+{
+  "providers": {
+    "my-proxy": {
+      "baseUrl": "http://localhost:4000",
+      "apiKey": "none",
+      "api": "anthropic-messages",
+      "models": [...]
+    }
+  }
+}
+```
+
+The plugin will automatically use `http://localhost:4000` with no API key.
+
+### Example: Direct API key
+
+```bash
+export ANTHROPIC_SEARCH_API_KEY=sk-ant-xxx
+```
+
+## Tools
+
+### `anthropic_web_search`
+
+Search the web using Claude's built-in web search capability.
+
+**Parameters:**
+
+- `query` (required): The search query or question
+- `system_prompt`: Guide the response style and focus
+- `max_tokens`: Maximum tokens in response (default: 4096)
+
+**Response includes:**
+
+- Synthesized answer with inline citations
+- List of sources with titles, URLs, and page ages
+- Search queries Claude generated
+
+## Configuration
+
+| Variable  | Env                         | Description                                        |
+| --------- | --------------------------- | -------------------------------------------------- |
+| `apiKey`  | `ANTHROPIC_SEARCH_API_KEY`  | API key (optional if using proxy/oauth)            |
+| `baseUrl` | `ANTHROPIC_SEARCH_BASE_URL` | Base URL override                                  |
+| `model`   | `ANTHROPIC_SEARCH_MODEL`    | Model to use (default: `claude-sonnet-4-20250514`) |
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@oh-my-pi/anthropic-websearch",
+  "version": "0.1.0",
+  "description": "Anthropic Claude web search tool for pi",
+  "keywords": [
+    "omp-plugin",
+    "anthropic",
+    "claude",
+    "web-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/anthropic-websearch"
+  },
+  "omp": {
+    "install": [
+      {
+        "src": "tools/anthropic-websearch/index.ts",
+        "dest": "agent/tools/anthropic-websearch/index.ts"
+      }
+    ],
+    "variables": {
+      "apiKey": {
+        "type": "string",
+        "env": "ANTHROPIC_SEARCH_API_KEY",
+        "description": "Anthropic API key for web search (optional if using models.json provider or oauth)",
+        "required": false
+      },
+      "baseUrl": {
+        "type": "string",
+        "env": "ANTHROPIC_SEARCH_BASE_URL",
+        "description": "Anthropic API base URL for web search (optional)",
+        "required": false
+      },
+      "model": {
+        "type": "string",
+        "env": "ANTHROPIC_SEARCH_MODEL",
+        "description": "Model to use for web search",
+        "default": "claude-sonnet-4-20250514"
+      }
+    }
+  },
+  "files": [
+    "tools"
+  ]
+}

package/tools/anthropic-websearch/index.ts

@@ -0,0 +1,404 @@
+/**
+ * Anthropic Web Search Tool
+ *
+ * Uses Claude's built-in web_search_20250305 tool to search the web.
+ *
+ * Auth resolution order:
+ *   1. ANTHROPIC_SEARCH_API_KEY / ANTHROPIC_SEARCH_BASE_URL env vars
+ *   2. Provider with api="anthropic-messages" in ~/.pi/agent/models.json
+ *   3. OAuth credentials in ~/.pi/agent/auth.json
+ *   4. ANTHROPIC_API_KEY / ANTHROPIC_BASE_URL as final fallback
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Type, type TSchema } from "@sinclair/typebox";
+import type {
+  CustomAgentTool,
+  CustomToolFactory,
+  ToolAPI,
+} from "@mariozechner/pi-coding-agent";
+
+const DEFAULT_BASE_URL = "https://api.anthropic.com";
+const DEFAULT_MODEL = "claude-sonnet-4-20250514";
+
+interface AuthConfig {
+  apiKey: string;
+  baseUrl: string;
+}
+
+interface ModelsJson {
+  providers?: Record<string, {
+    baseUrl?: string;
+    apiKey?: string;
+    api?: string;
+  }>;
+}
+
+interface AuthJson {
+  anthropic?: {
+    type: "oauth";
+    access: string;
+    expires: number;
+  };
+}
+
+/**
+ * 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();
+
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
+        value = value.slice(1, -1);
+      }
+
+      result[key] = value;
+    }
+  } catch {
+    // Ignore read errors
+  }
+
+  return result;
+}
+
+/**
+ * Get env var from process.env or .env files
+ */
+function getEnv(key: string): string | undefined {
+  if (process.env[key]) return process.env[key];
+
+  const localEnv = parseEnvFile(path.join(process.cwd(), ".env"));
+  if (localEnv[key]) return localEnv[key];
+
+  const homeEnv = parseEnvFile(path.join(os.homedir(), ".env"));
+  if (homeEnv[key]) return homeEnv[key];
+
+  return undefined;
+}
+
+/**
+ * Read JSON file safely
+ */
+function readJson<T>(filePath: string): T | null {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find auth config using priority order:
+ * 1. ANTHROPIC_SEARCH_API_KEY / ANTHROPIC_SEARCH_BASE_URL
+ * 2. Provider with api="anthropic-messages" in models.json
+ * 3. OAuth in auth.json
+ * 4. ANTHROPIC_API_KEY / ANTHROPIC_BASE_URL fallback
+ */
+function findAuthConfig(): AuthConfig | null {
+  const piAgentDir = path.join(os.homedir(), ".pi", "agent");
+
+  // 1. Explicit search-specific env vars
+  const searchApiKey = getEnv("ANTHROPIC_SEARCH_API_KEY");
+  const searchBaseUrl = getEnv("ANTHROPIC_SEARCH_BASE_URL");
+  if (searchApiKey) {
+    return {
+      apiKey: searchApiKey,
+      baseUrl: searchBaseUrl ?? DEFAULT_BASE_URL,
+    };
+  }
+
+  // 2. Provider with api="anthropic-messages" in models.json
+  const modelsJson = readJson<ModelsJson>(path.join(piAgentDir, "models.json"));
+  if (modelsJson?.providers) {
+    for (const [_name, provider] of Object.entries(modelsJson.providers)) {
+      if (provider.api === "anthropic-messages" && provider.apiKey && provider.apiKey !== "none") {
+        return {
+          apiKey: provider.apiKey,
+          baseUrl: provider.baseUrl ?? DEFAULT_BASE_URL,
+        };
+      }
+    }
+    // Also check for providers with baseUrl but apiKey="none" (proxy)
+    for (const [_name, provider] of Object.entries(modelsJson.providers)) {
+      if (provider.api === "anthropic-messages" && provider.baseUrl) {
+        return {
+          apiKey: provider.apiKey ?? "",
+          baseUrl: provider.baseUrl,
+        };
+      }
+    }
+  }
+
+  // 3. OAuth credentials in auth.json
+  const authJson = readJson<AuthJson>(path.join(piAgentDir, "auth.json"));
+  if (authJson?.anthropic?.type === "oauth" && authJson.anthropic.access) {
+    // Check if not expired
+    if (authJson.anthropic.expires > Date.now()) {
+      return {
+        apiKey: authJson.anthropic.access,
+        baseUrl: DEFAULT_BASE_URL,
+      };
+    }
+  }
+
+  // 4. Generic ANTHROPIC_API_KEY fallback
+  const apiKey = getEnv("ANTHROPIC_API_KEY");
+  const baseUrl = getEnv("ANTHROPIC_BASE_URL");
+  if (apiKey) {
+    return {
+      apiKey,
+      baseUrl: baseUrl ?? DEFAULT_BASE_URL,
+    };
+  }
+
+  return null;
+}
+
+// Response types
+interface ServerToolUse {
+  type: "server_tool_use";
+  id: string;
+  name: "web_search";
+  input: { query: string };
+}
+
+interface WebSearchResult {
+  type: "web_search_result";
+  title: string;
+  url: string;
+  encrypted_content: string;
+  page_age: string | null;
+}
+
+interface WebSearchToolResult {
+  type: "web_search_tool_result";
+  tool_use_id: string;
+  content: WebSearchResult[];
+}
+
+interface Citation {
+  type: "web_search_result_location";
+  url: string;
+  title: string;
+  cited_text: string;
+  encrypted_index: string;
+}
+
+interface TextBlock {
+  type: "text";
+  text: string;
+  citations?: Citation[];
+}
+
+type ContentBlock = ServerToolUse | WebSearchToolResult | TextBlock;
+
+interface MessagesResponse {
+  id: string;
+  type: string;
+  role: string;
+  content: ContentBlock[];
+  model: string;
+  stop_reason: string;
+  usage: {
+    input_tokens: number;
+    output_tokens: number;
+  };
+}
+
+/**
+ * Call Anthropic Messages API with web search tool
+ */
+async function callAnthropicWebSearch(
+  auth: AuthConfig,
+  query: string,
+  model: string,
+  systemPrompt?: string,
+  maxTokens?: number,
+): Promise<MessagesResponse> {
+  const url = `${auth.baseUrl}/v1/messages`;
+
+  const body: Record<string, unknown> = {
+    model,
+    max_tokens: maxTokens ?? 4096,
+    messages: [{ role: "user", content: query }],
+    tools: [{ type: "web_search_20250305", name: "web_search" }],
+  };
+
+  if (systemPrompt) {
+    body.system = systemPrompt;
+  }
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "anthropic-version": "2023-06-01",
+  };
+
+  // Handle different auth types
+  if (auth.apiKey.startsWith("sk-ant-")) {
+    headers["x-api-key"] = auth.apiKey;
+  } else if (auth.apiKey && auth.apiKey !== "none") {
+    // OAuth token or other bearer token
+    headers["Authorization"] = `Bearer ${auth.apiKey}`;
+  }
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Anthropic API error (${response.status}): ${errorText}`);
+  }
+
+  return response.json() as Promise<MessagesResponse>;
+}
+
+/**
+ * Format response for display
+ */
+function formatResponse(response: MessagesResponse): { text: string; details: unknown } {
+  const parts: string[] = [];
+  const searchQueries: string[] = [];
+  const sources: Array<{ title: string; url: string; age: string | null }> = [];
+  const citations: Citation[] = [];
+
+  for (const block of response.content) {
+    if (block.type === "server_tool_use" && block.name === "web_search") {
+      searchQueries.push(block.input.query);
+    } else if (block.type === "web_search_tool_result") {
+      for (const result of block.content) {
+        if (result.type === "web_search_result") {
+          sources.push({
+            title: result.title,
+            url: result.url,
+            age: result.page_age,
+          });
+        }
+      }
+    } else if (block.type === "text") {
+      parts.push(block.text);
+      if (block.citations) {
+        citations.push(...block.citations);
+      }
+    }
+  }
+
+  let text = parts.join("\n\n");
+
+  // Add sources
+  if (sources.length > 0) {
+    text += "\n\n## Sources";
+    for (const [i, src] of sources.entries()) {
+      const age = src.age ? ` (${src.age})` : "";
+      text += `\n[${i + 1}] ${src.title}${age}\n    ${src.url}`;
+    }
+  }
+
+  return {
+    text,
+    details: {
+      model: response.model,
+      usage: response.usage,
+      searchQueries,
+      sources,
+      citations: citations.map((c) => ({
+        url: c.url,
+        title: c.title,
+        citedText: c.cited_text,
+      })),
+    },
+  };
+}
+
+// Tool schema
+const SearchSchema = Type.Object({
+  query: Type.String({
+    description: "The search query or question to answer using web search",
+  }),
+  system_prompt: Type.Optional(
+    Type.String({
+      description: "System prompt to guide the response style and focus",
+    }),
+  ),
+  max_tokens: Type.Optional(
+    Type.Number({
+      description: "Maximum tokens in response (default: 4096)",
+      minimum: 1,
+      maximum: 16384,
+    }),
+  ),
+});
+
+type SearchParams = {
+  query: string;
+  system_prompt?: string;
+  max_tokens?: number;
+};
+
+const factory: CustomToolFactory = async (
+  _toolApi: ToolAPI,
+): Promise<CustomAgentTool<TSchema, unknown>[] | null> => {
+  const auth = findAuthConfig();
+  if (!auth) {
+    console.error("anthropic-websearch: No auth config found. Set ANTHROPIC_SEARCH_API_KEY or configure models.json/auth.json");
+    return null;
+  }
+
+  const model = getEnv("ANTHROPIC_SEARCH_MODEL") ?? DEFAULT_MODEL;
+
+  const tool: CustomAgentTool<typeof SearchSchema, unknown> = {
+    name: "anthropic_web_search",
+    label: "Anthropic Web Search",
+    description: `Web search powered by Claude (${model}). Uses Claude's built-in web search capability to find current information and synthesize answers with citations. Best for questions requiring up-to-date information from the web.`,
+    parameters: SearchSchema,
+    async execute(_toolCallId, params) {
+      try {
+        const p = (params ?? {}) as SearchParams;
+        const response = await callAnthropicWebSearch(
+          auth,
+          p.query,
+          model,
+          p.system_prompt,
+          p.max_tokens,
+        );
+        const { text, details } = formatResponse(response);
+        return {
+          content: [{ type: "text" as const, text }],
+          details,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text" as const, text: `Error: ${message}` }],
+          details: { error: message },
+        };
+      }
+    },
+  };
+
+  return [tool];
+};
+
+export default factory;