pi-web-scout 0.1.0 → 0.1.1

package/README.md

@@ -10,6 +10,12 @@ No-key web search extension for [Pi](https://pi.dev). It registers a `web_search
 - No credential command execution.
 - Provider architecture ready for future keyed APIs such as Brave, Serper, Tavily, Exa, etc.
 
+## Install
+
+```bash
+pi install npm:pi-web-scout
+```
+
 ## Try locally
 
 ```bash
@@ -89,6 +95,18 @@ The extension currently reads project config only and does not write config file
 
 `mode: "combine"` queries all enabled providers in the fallback chain, deduplicates URLs, and ranks repeated results higher with a simple reciprocal-rank score.
 
+## Compatibility aliases
+
+`web_search` accepts these argument aliases:
+
+- `maxResults` → `max_results`
+- `provider: "ddg"` → `"duckduckgo"`
+- `mode: "first-success"` → `"first_success"`
+
+`web_read` accepts:
+
+- `maxChars` → `max_chars`
+
 ## Security notes
 
 This package intentionally avoids:

package/SECURITY.md

@@ -37,7 +37,7 @@ PI_WEB_SCOUT_BRAVE_API_KEY
 
 ## SSRF notes
 
-`web_read` blocks common local/private/metadata targets and validates every redirect hop. It does not perform custom DNS resolution, so DNS rebinding protection is best-effort.
+`web_read` blocks common local/private/metadata targets and validates every redirect hop. It does not perform custom DNS resolution, so DNS rebinding protection is best-effort and DNS rebinding is not fully blocked.
 
 ## Reporting
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-web-scout",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "No-key web search extension for Pi, with provider architecture ready for keyed search APIs.",
   "type": "module",
   "main": "./index.ts",

package/src/format.ts

@@ -13,7 +13,8 @@ export function formatSearchResults(
     lines.push("", "Provider runs:");
     for (const run of runs) {
       const status = run.error ? `failed: ${run.error}` : `${run.results.length} result${run.results.length === 1 ? "" : "s"}`;
-      lines.push(`- ${run.provider}: ${status}`);
+      const suffix = run.keySource ? ` (${run.keySource})` : "";
+      lines.push(`- ${run.provider}: ${status}${suffix}`);
     }
   }
   lines.push("");

package/src/providers/jina.ts

@@ -28,7 +28,10 @@ export const jinaProvider: SearchProvider = {
     });
 
     if (!response.ok) {
-      throw new Error(`Jina returned HTTP ${response.status}`);
+      const hint = response.status === 401 || response.status === 403
+        ? " (Jina may require an API key or may be rate-limiting no-key requests)"
+        : "";
+      throw new Error(`Jina returned HTTP ${response.status}${hint}`);
     }
 
     return parseJinaResponse(await response.json(), request.maxResults);

package/src/tool.ts

@@ -12,20 +12,39 @@ import type { ProviderId, ProviderRunResult, ResolvedConfig, SearchMode, SearchR
 const PROVIDERS = ["auto", "duckduckgo", "marginalia", "jina", "brave"] as const;
 const MODES = ["first_success", "combine"] as const;
 
+function normalizeSearchArgs(args: unknown): unknown {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+  const next = { ...(args as Record<string, unknown>) };
+  if (next.max_results === undefined && next.maxResults !== undefined) next.max_results = next.maxResults;
+  if (next.provider === "ddg") next.provider = "duckduckgo";
+  if (next.mode === "first-success") next.mode = "first_success";
+  return next;
+}
+
+function normalizeReadArgs(args: unknown): unknown {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+  const next = { ...(args as Record<string, unknown>) };
+  if (next.max_chars === undefined && next.maxChars !== undefined) next.max_chars = next.maxChars;
+  return next;
+}
+
 export function registerWebSearchTool(pi: ExtensionAPI): void {
   registerStatusCommand(pi);
 
   pi.registerTool({
     name: "web_search",
-    label: "Web Scout Search",
+    label: "Pi Web Scout Search",
     description:
-      "Search the web using no-key search providers. Defaults to DuckDuckGo HTML and is architected for future keyed providers.",
+      "pi-web-scout: search the web using no-key search providers. Defaults to DuckDuckGo HTML and is architected for future keyed providers.",
     promptSnippet: "web_search: search the public web without requiring API keys.",
     promptGuidelines: [
       "Use web_search when current or source-backed information is needed.",
       "Prefer web_search over guessing facts that may have changed recently.",
       "Use web_search with mode=combine when broad coverage matters more than speed.",
     ],
+    prepareArguments(args) {
+      return normalizeSearchArgs(args);
+    },
     parameters: Type.Object({
       query: Type.String({ description: "Search query" }),
       max_results: Type.Optional(Type.Number({ description: "Number of results, 1-20. Default comes from config or 5." })),
@@ -68,6 +87,7 @@ export function registerWebSearchTool(pi: ExtensionAPI): void {
             provider: run.provider,
             resultCount: run.results.length,
             error: run.error,
+            keySource: run.keySource,
           })),
           results: runResult.results,
         },
@@ -77,13 +97,16 @@ export function registerWebSearchTool(pi: ExtensionAPI): void {
 
   pi.registerTool({
     name: "web_read",
-    label: "Web Read",
-    description: "Fetch a public HTTP(S) URL and extract readable text with SSRF protection. No browser or JavaScript execution.",
+    label: "Pi Web Scout Read",
+    description: "pi-web-scout: fetch a public HTTP(S) URL and extract readable text with SSRF protection. No browser or JavaScript execution.",
     promptSnippet: "web_read: read and extract text from a specific public URL.",
     promptGuidelines: [
       "Use web_read after web_search when snippets are insufficient and a source needs to be read.",
       "Do not use web_read for localhost, private network, or metadata URLs; those are blocked.",
     ],
+    prepareArguments(args) {
+      return normalizeReadArgs(args);
+    },
     parameters: Type.Object({
       url: Type.String({ description: "Public HTTP(S) URL to read" }),
       max_chars: Type.Optional(Type.Number({ description: "Maximum extracted characters, 1000-50000. Default 12000." })),