bashkit 0.2.2 → 0.2.4

package/AGENTS.md

@@ -21,9 +21,9 @@ bun add bashkit ai @ai-sdk/anthropic
 Runs commands directly on the local machine. Use for development/testing only.
 
 ```typescript
-import { createAgentTools, LocalSandbox } from "bashkit";
+import { createAgentTools, createLocalSandbox } from "bashkit";
 
-const sandbox = new LocalSandbox("/tmp/workspace");
+const sandbox = createLocalSandbox({ cwd: "/tmp/workspace" });
 const { tools } = createAgentTools(sandbox);
 ```
 
@@ -32,9 +32,9 @@ const { tools } = createAgentTools(sandbox);
 Runs in isolated Firecracker microVMs on Vercel's infrastructure.
 
 ```typescript
-import { createAgentTools, VercelSandbox } from "bashkit";
+import { createAgentTools, createVercelSandbox } from "bashkit";
 
-const sandbox = new VercelSandbox({
+const sandbox = createVercelSandbox({
   runtime: "node22",
   resources: { vcpus: 2 },
 });
@@ -44,6 +44,49 @@ const { tools } = createAgentTools(sandbox);
 await sandbox.destroy();
 ```
 
+### E2BSandbox (Production)
+
+Runs in E2B's cloud sandboxes. Requires `@e2b/code-interpreter` peer dependency.
+
+```typescript
+import { createAgentTools, createE2BSandbox } from "bashkit";
+
+const sandbox = createE2BSandbox({
+  apiKey: process.env.E2B_API_KEY,
+});
+const { tools } = createAgentTools(sandbox);
+
+await sandbox.destroy();
+```
+
+### Sandbox Reconnection (Cloud Sandboxes)
+
+Cloud sandboxes (E2B, Vercel) support reconnection via the `id` property and `sandboxId` config:
+
+```typescript
+// Create a new sandbox
+const sandbox = createE2BSandbox({ apiKey: process.env.E2B_API_KEY });
+
+// After first operation, the sandbox ID is available
+await sandbox.exec("echo hello");
+const sandboxId = sandbox.id; // "sbx_abc123..."
+
+// Store sandboxId in your database (e.g., chat metadata)
+await db.chat.update({ where: { id: chatId }, data: { sandboxId } });
+
+// Later: reconnect to the same sandbox
+const savedId = chat.sandboxId;
+const reconnected = createE2BSandbox({
+  apiKey: process.env.E2B_API_KEY,
+  sandboxId: savedId, // Reconnects instead of creating new
+});
+```
+
+This is useful for:
+- Reusing sandboxes across multiple requests in the same conversation
+- Persisting sandbox state between server restarts
+- Reducing sandbox creation overhead
+
 ## Available Tools
 
 ### Default Tools (always included)
@@ -89,11 +132,11 @@ import { generateText, wrapLanguageModel, stepCountIs } from "ai";
 import { anthropic } from "@ai-sdk/anthropic";
 import {
   createAgentTools,
-  LocalSandbox,
+  createLocalSandbox,
   anthropicPromptCacheMiddleware,
 } from "bashkit";
 
-const sandbox = new LocalSandbox("/tmp/workspace");
+const sandbox = createLocalSandbox({ cwd: "/tmp/workspace" });
 const { tools } = createAgentTools(sandbox);
 
 // Wrap model with prompt caching (recommended)
@@ -311,12 +354,12 @@ const skills = await discoverSkills();
 ### Using Skills with Agents
 
 ```typescript
-import { discoverSkills, skillsToXml, createAgentTools, LocalSandbox } from "bashkit";
+import { discoverSkills, skillsToXml, createAgentTools, createLocalSandbox } from "bashkit";
 import { generateText, stepCountIs } from "ai";
 import { anthropic } from "@ai-sdk/anthropic";
 
 const skills = await discoverSkills();
-const sandbox = new LocalSandbox("/tmp/workspace");
+const sandbox = createLocalSandbox({ cwd: "/tmp/workspace" });
 const { tools } = createAgentTools(sandbox);
 
 const result = await generateText({
@@ -421,13 +464,13 @@ import {
   createAgentTools,
   createTaskTool,
   createTodoWriteTool,
-  LocalSandbox,
+  createLocalSandbox,
   anthropicPromptCacheMiddleware,
   type TodoState,
 } from "bashkit";
 
 // 1. Create sandbox
-const sandbox = new LocalSandbox("/tmp/workspace");
+const sandbox = createLocalSandbox({ cwd: "/tmp/workspace" });
 
 // 2. Create sandbox tools
 const { tools: sandboxTools } = createAgentTools(sandbox);
@@ -489,9 +532,9 @@ const { tools } = createAgentTools(sandbox, {
 Cache tool execution results to avoid redundant operations:
 
 ```typescript
-import { createAgentTools, LocalSandbox } from "bashkit";
+import { createAgentTools, createLocalSandbox } from "bashkit";
 
-const sandbox = new LocalSandbox("/tmp/workspace");
+const sandbox = createLocalSandbox({ cwd: "/tmp/workspace" });
 
 // Enable caching with defaults (LRU, 5min TTL)
 const { tools } = createAgentTools(sandbox, { cache: true });

package/README.md

@@ -148,6 +148,15 @@ const sandbox = createVercelSandbox({
   runtime: 'node22',
   resources: { vcpus: 2 },
 });
+
+// After first operation, get the sandbox ID for persistence
+await sandbox.exec('echo hello');
+console.log(sandbox.id); // Sandbox ID for reconnection
+
+// Later: reconnect to the same sandbox
+const reconnected = createVercelSandbox({
+  sandboxId: 'existing-sandbox-id',
+});
 ```
 
 ### E2BSandbox
@@ -158,7 +167,17 @@ Runs in E2B's cloud sandboxes. Requires `@e2b/code-interpreter` peer dependency.
 import { createE2BSandbox } from 'bashkit';
 
 const sandbox = createE2BSandbox({
-  // E2B config
+  apiKey: process.env.E2B_API_KEY,
+});
+
+// After first operation, get the sandbox ID for persistence
+await sandbox.exec('echo hello');
+console.log(sandbox.id); // "sbx_abc123..."
+
+// Later: reconnect to the same sandbox
+const reconnected = createE2BSandbox({
+  apiKey: process.env.E2B_API_KEY,
+  sandboxId: 'sbx_abc123...', // Reconnect to existing sandbox
 });
 ```
 
@@ -764,9 +783,14 @@ interface Sandbox {
   readDir(path: string): Promise<string[]>;
   fileExists(path: string): Promise<boolean>;
   destroy(): Promise<void>;
+
+  // Optional: Sandbox ID for reconnection (cloud providers only)
+  readonly id?: string;
 }
 ```
 
+The `id` property is available on cloud sandboxes (E2B, Vercel) after the first operation. Use it to persist the sandbox ID and reconnect later.
+
 ### Custom Sandbox Example
 
 ```typescript

package/dist/index.js

@@ -50,7 +50,6 @@ var anthropicPromptCacheMiddleware = {
   transformParams: async ({ params }) => applyCacheMarkers(params)
 };
 // src/sandbox/e2b.ts
-import { Sandbox as E2BSandboxSDK } from "@e2b/code-interpreter";
 function createE2BSandbox(config = {}) {
   let sandbox = null;
   let sandboxId = config.sandboxId;
@@ -59,6 +58,13 @@ function createE2BSandbox(config = {}) {
   const ensureSandbox = async () => {
     if (sandbox)
       return sandbox;
+    let E2BSandboxSDK;
+    try {
+      const module = await import("@e2b/code-interpreter");
+      E2BSandboxSDK = module.Sandbox;
+    } catch {
+      throw new Error("E2BSandbox requires @e2b/code-interpreter. Install with: npm install @e2b/code-interpreter");
+    }
     if (config.sandboxId) {
       sandbox = await E2BSandboxSDK.connect(config.sandboxId);
     } else {
@@ -233,7 +239,6 @@ function createLocalSandbox(config = {}) {
   };
 }
 // src/sandbox/vercel.ts
-import { Sandbox as VercelSandboxSDK } from "@vercel/sandbox";
 function createVercelSandbox(config = {}) {
   let sandbox = null;
   let sandboxId = config.sandboxId;
@@ -246,6 +251,13 @@ function createVercelSandbox(config = {}) {
   const ensureSandbox = async () => {
     if (sandbox)
       return sandbox;
+    let VercelSandboxSDK;
+    try {
+      const module = await import("@vercel/sandbox");
+      VercelSandboxSDK = module.Sandbox;
+    } catch {
+      throw new Error("VercelSandbox requires @vercel/sandbox. Install with: npm install @vercel/sandbox");
+    }
     const createOptions = {
       runtime: resolvedConfig.runtime,
       resources: resolvedConfig.resources,
@@ -979,6 +991,7 @@ function createGlobTool(sandbox, config) {
 // src/tools/grep.ts
 import { tool as tool7, zodSchema as zodSchema7 } from "ai";
 import { z as z7 } from "zod";
+import { rgPath } from "@vscode/ripgrep";
 var grepInputSchema = z7.object({
   pattern: z7.string().describe("The regular expression pattern to search for in file contents"),
   path: z7.string().optional().describe("File or directory to search in (defaults to cwd)"),
@@ -992,13 +1005,13 @@ var grepInputSchema = z7.object({
   "-C": z7.number().optional().describe("Number of lines to show before and after each match. Requires output_mode: 'content'."),
   head_limit: z7.number().optional().describe("Limit output to first N lines/entries. Works across all output modes. Defaults to 0 (unlimited)."),
   offset: z7.number().optional().describe("Skip first N lines/entries before applying head_limit. Works across all output modes. Defaults to 0."),
-  multiline: z7.boolean().optional().describe("Enable multiline mode where patterns can span lines (requires ripgrep). Default: false.")
+  multiline: z7.boolean().optional().describe("Enable multiline mode where patterns can span lines. Default: false.")
 });
-var GREP_DESCRIPTION = `A powerful content search tool with regex support. Use this instead of running grep commands directly.
+var GREP_DESCRIPTION = `A powerful content search tool built on ripgrep with regex support.
 
 **Usage:**
 - ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command.
-- Supports regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
 - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
 
 **Output modes:**
@@ -1013,11 +1026,8 @@ var GREP_DESCRIPTION = `A powerful content search tool with regex support. Use t
 
 **Pagination:**
 - Use offset to skip results (useful for pagination)
-- Use head_limit to limit total results returned
-
-**Note:** Set useRipgrep: true in config for better performance and multiline support (requires ripgrep installed).`;
+- Use head_limit to limit total results returned`;
 function createGrepTool(sandbox, config) {
-  const useRipgrep = config?.useRipgrep ?? false;
   return tool7({
     description: GREP_DESCRIPTION,
     inputSchema: zodSchema7(grepInputSchema),
@@ -1032,7 +1042,6 @@ function createGrepTool(sandbox, config) {
         type,
         output_mode = "files_with_matches",
         "-i": caseInsensitive,
-        "-n": showLineNumbers = true,
         "-B": beforeContext,
         "-A": afterContext,
         "-C": context,
@@ -1047,98 +1056,26 @@ function createGrepTool(sandbox, config) {
           return { error: `Path not allowed: ${searchPath}` };
         }
       }
-      if (multiline && !useRipgrep) {
-        return {
-          error: "Multiline mode requires ripgrep. Set useRipgrep: true in config."
-        };
-      }
       try {
-        let paginationSuffix = "";
-        if (offset > 0) {
-          paginationSuffix += ` | tail -n +${offset + 1}`;
-        }
-        if (head_limit && head_limit > 0) {
-          paginationSuffix += ` | head -${head_limit}`;
-        }
-        let cmd;
-        if (useRipgrep) {
-          cmd = buildRipgrepCommand({
-            pattern,
-            searchPath,
-            output_mode,
-            caseInsensitive,
-            showLineNumbers,
-            beforeContext,
-            afterContext,
-            context,
-            glob,
-            type,
-            multiline,
-            paginationSuffix
-          });
-        } else {
-          cmd = buildGrepCommand({
-            pattern,
-            searchPath,
-            output_mode,
-            caseInsensitive,
-            showLineNumbers,
-            beforeContext,
-            afterContext,
-            context,
-            glob,
-            type,
-            paginationSuffix
-          });
-        }
+        const cmd = buildRipgrepCommand({
+          pattern,
+          searchPath,
+          output_mode,
+          caseInsensitive,
+          beforeContext,
+          afterContext,
+          context,
+          glob,
+          type,
+          multiline
+        });
         const result = await sandbox.exec(cmd, { timeout: config?.timeout });
         if (output_mode === "files_with_matches") {
-          const files = result.stdout.split(`
-`).filter(Boolean);
-          return {
-            files,
-            count: files.length
-          };
+          return parseFilesOutput(result.stdout);
         } else if (output_mode === "count") {
-          const lines = result.stdout.split(`
-`).filter(Boolean);
-          const counts = lines.map((line) => {
-            const lastColon = line.lastIndexOf(":");
-            return {
-              file: line.slice(0, lastColon),
-              count: parseInt(line.slice(lastColon + 1), 10)
-            };
-          });
-          const total = counts.reduce((sum, c) => sum + c.count, 0);
-          return {
-            counts,
-            total
-          };
+          return parseCountOutput(result.stdout);
         } else {
-          if (!result.stdout.trim()) {
-            return {
-              matches: [],
-              total_matches: 0
-            };
-          }
-          const lines = result.stdout.split(`
-`).filter(Boolean);
-          const matches = [];
-          for (const line of lines) {
-            const colonMatch = line.match(/^(.+?):(\d+)[:|-](.*)$/);
-            if (colonMatch) {
-              const [, file, lineNum, content] = colonMatch;
-              matches.push({
-                file,
-                line_number: parseInt(lineNum, 10),
-                line: content
-              });
-            }
-          }
-          return {
-            matches,
-            total_matches: matches.length
-          };
+          return parseContentOutput(result.stdout, head_limit, offset);
         }
       } catch (error) {
         return {
@@ -1149,14 +1086,12 @@ function createGrepTool(sandbox, config) {
   });
 }
 function buildRipgrepCommand(opts) {
-  const flags = [];
+  const flags = ["--json"];
   if (opts.caseInsensitive)
     flags.push("-i");
   if (opts.multiline)
     flags.push("-U", "--multiline-dotall");
   if (opts.output_mode === "content") {
-    if (opts.showLineNumbers)
-      flags.push("-n");
     if (opts.context) {
       flags.push(`-C ${opts.context}`);
     } else {
@@ -1171,42 +1106,137 @@ function buildRipgrepCommand(opts) {
   if (opts.type)
     flags.push(`-t ${opts.type}`);
   const flagStr = flags.join(" ");
-  if (opts.output_mode === "files_with_matches") {
-    return `rg -l ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null${opts.paginationSuffix}`;
-  } else if (opts.output_mode === "count") {
-    return `rg -c ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null${opts.paginationSuffix}`;
-  } else {
-    return `rg ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null${opts.paginationSuffix}`;
+  return `${rgPath} ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null`;
+}
+function parseFilesOutput(stdout) {
+  const files = new Set;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "begin") {
+        const data = msg.data;
+        files.add(data.path.text);
+      }
+    } catch {}
   }
+  return {
+    files: Array.from(files),
+    count: files.size
+  };
 }
-function buildGrepCommand(opts) {
-  const flags = ["-r"];
-  if (opts.caseInsensitive)
-    flags.push("-i");
-  if (opts.output_mode === "content") {
-    if (opts.showLineNumbers)
-      flags.push("-n");
-    if (opts.context) {
-      flags.push(`-C ${opts.context}`);
-    } else {
-      if (opts.beforeContext)
-        flags.push(`-B ${opts.beforeContext}`);
-      if (opts.afterContext)
-        flags.push(`-A ${opts.afterContext}`);
+function parseCountOutput(stdout) {
+  const counts = new Map;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "end") {
+        const data = msg.data;
+        counts.set(data.path.text, data.stats.matches);
+      }
+    } catch {}
+  }
+  const countsArray = Array.from(counts.entries()).map(([file, count]) => ({
+    file,
+    count
+  }));
+  const total = countsArray.reduce((sum, c) => sum + c.count, 0);
+  return {
+    counts: countsArray,
+    total
+  };
+}
+function parseContentOutput(stdout, head_limit, offset = 0) {
+  const fileData = new Map;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "begin") {
+        const data = msg.data;
+        fileData.set(data.path.text, { matches: [], contexts: [] });
+      } else if (msg.type === "context") {
+        const data = msg.data;
+        const fd = fileData.get(data.path.text);
+        if (fd) {
+          fd.contexts.push({
+            line_number: data.line_number,
+            text: data.lines.text.replace(/\n$/, "")
+          });
+        }
+      } else if (msg.type === "match") {
+        const data = msg.data;
+        const fd = fileData.get(data.path.text);
+        if (fd) {
+          fd.matches.push({
+            line_number: data.line_number,
+            text: data.lines.text.replace(/\n$/, "")
+          });
+        }
+      }
+    } catch {}
+  }
+  const allMatches = [];
+  for (const [file, { matches, contexts }] of fileData) {
+    matches.sort((a, b) => a.line_number - b.line_number);
+    contexts.sort((a, b) => a.line_number - b.line_number);
+    const matchContexts = new Map;
+    for (const match of matches) {
+      matchContexts.set(match.line_number, { before: [], after: [] });
+    }
+    for (const ctx of contexts) {
+      let bestMatch = null;
+      let bestDistance = Infinity;
+      let isBefore = false;
+      for (const match of matches) {
+        const distance = Math.abs(ctx.line_number - match.line_number);
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          bestMatch = match;
+          isBefore = ctx.line_number < match.line_number;
+        }
+      }
+      if (bestMatch) {
+        const mc = matchContexts.get(bestMatch.line_number);
+        if (mc) {
+          if (isBefore) {
+            mc.before.push(ctx.text);
+          } else {
+            mc.after.push(ctx.text);
+          }
+        }
+      }
+    }
+    for (const match of matches) {
+      const mc = matchContexts.get(match.line_number);
+      allMatches.push({
+        file,
+        line_number: match.line_number,
+        line: match.text,
+        before_context: mc?.before ?? [],
+        after_context: mc?.after ?? []
+      });
     }
   }
-  if (opts.glob)
-    flags.push(`--include="${opts.glob}"`);
-  if (opts.type)
-    flags.push(`--include="*.${opts.type}"`);
-  const flagStr = flags.join(" ");
-  if (opts.output_mode === "files_with_matches") {
-    return `grep -l ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null${opts.paginationSuffix}`;
-  } else if (opts.output_mode === "count") {
-    return `grep -c ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null | grep -v ':0$'${opts.paginationSuffix}`;
-  } else {
-    return `grep ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null${opts.paginationSuffix}`;
+  const grepMatches = allMatches.map((m) => ({
+    file: m.file,
+    line_number: m.line_number,
+    line: m.line,
+    before_context: m.before_context.length > 0 ? m.before_context : undefined,
+    after_context: m.after_context.length > 0 ? m.after_context : undefined
+  }));
+  let result = grepMatches;
+  if (offset > 0) {
+    result = result.slice(offset);
   }
+  if (head_limit && head_limit > 0) {
+    result = result.slice(0, head_limit);
+  }
+  return {
+    matches: result,
+    total_matches: result.length
+  };
 }
 
 // src/tools/read.ts
@@ -1390,13 +1420,56 @@ function createSkillTool(config) {
 
 // src/tools/web-fetch.ts
 import { generateText, tool as tool10, zodSchema as zodSchema10 } from "ai";
-import Parallel from "parallel-web";
 import { z as z10 } from "zod";
 
 // src/utils/http-constants.ts
 var RETRYABLE_STATUS_CODES = [408, 429, 500, 502, 503];
 
 // src/tools/web-fetch.ts
+var parallelModule = null;
+async function getParallelModule() {
+  if (!parallelModule) {
+    try {
+      parallelModule = await import("parallel-web");
+    } catch {
+      throw new Error("WebFetch requires parallel-web. Install with: npm install parallel-web");
+    }
+  }
+  return parallelModule;
+}
+async function fetchWithParallel(url, apiKey) {
+  const { default: Parallel } = await getParallelModule();
+  const client = new Parallel({ apiKey });
+  const extract = await client.beta.extract({
+    urls: [url],
+    excerpts: true,
+    full_content: true
+  });
+  if (!extract.results || extract.results.length === 0) {
+    throw new Error("No content extracted from URL");
+  }
+  const result = extract.results[0];
+  const content = result.full_content || result.excerpts?.join(`
+
+`) || "";
+  if (!content) {
+    throw new Error("No content available from URL");
+  }
+  return {
+    content,
+    finalUrl: result.url
+  };
+}
+async function fetchContent(url, apiKey, provider) {
+  switch (provider) {
+    case "parallel":
+      return fetchWithParallel(url, apiKey);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`Unknown provider: ${_exhaustive}`);
+    }
+  }
+}
 var webFetchInputSchema = z10.object({
   url: z10.string().describe("The URL to fetch content from"),
   prompt: z10.string().describe("The prompt to run on the fetched content")
@@ -1418,7 +1491,14 @@ Usage notes:
   - When a URL redirects to a different host, the tool will inform you and provide the redirect URL. You should then make a new WebFetch request with the redirect URL to fetch the content.
 `;
 function createWebFetchTool(config) {
-  const { apiKey, model, strict, needsApproval, providerOptions } = config;
+  const {
+    provider = "parallel",
+    apiKey,
+    model,
+    strict,
+    needsApproval,
+    providerOptions
+  } = config;
   return tool10({
     description: WEB_FETCH_DESCRIPTION,
     inputSchema: zodSchema10(webFetchInputSchema),
@@ -1428,30 +1508,7 @@ function createWebFetchTool(config) {
     execute: async (input) => {
       const { url, prompt } = input;
       try {
-        const client = new Parallel({ apiKey });
-        const extract = await client.beta.extract({
-          urls: [url],
-          excerpts: true,
-          full_content: true
-        });
-        if (!extract.results || extract.results.length === 0) {
-          return {
-            error: "No content extracted from URL",
-            status_code: 404,
-            retryable: false
-          };
-        }
-        const extractedResult = extract.results[0];
-        const content = extractedResult.full_content || extractedResult.excerpts?.join(`
-
-`) || "";
-        if (!content) {
-          return {
-            error: "No content available from URL",
-            status_code: 404,
-            retryable: false
-          };
-        }
+        const { content, finalUrl } = await fetchContent(url, apiKey, provider);
         const result = await generateText({
           model,
           prompt: `${prompt}
@@ -1463,7 +1520,7 @@ ${content}`
         return {
           response: result.text,
           url,
-          final_url: extractedResult.url || url
+          final_url: finalUrl || url
         };
       } catch (error) {
         if (error && typeof error === "object" && "status" in error) {
@@ -1485,8 +1542,53 @@ ${content}`
 
 // src/tools/web-search.ts
 import { tool as tool11, zodSchema as zodSchema11 } from "ai";
-import Parallel2 from "parallel-web";
 import { z as z11 } from "zod";
+var parallelModule2 = null;
+async function getParallelModule2() {
+  if (!parallelModule2) {
+    try {
+      parallelModule2 = await import("parallel-web");
+    } catch {
+      throw new Error("WebSearch requires parallel-web. Install with: npm install parallel-web");
+    }
+  }
+  return parallelModule2;
+}
+async function searchWithParallel(apiKey, options) {
+  const { default: Parallel } = await getParallelModule2();
+  const client = new Parallel({ apiKey });
+  const sourcePolicy = options.allowedDomains || options.blockedDomains ? {
+    ...options.allowedDomains && {
+      include_domains: options.allowedDomains
+    },
+    ...options.blockedDomains && {
+      exclude_domains: options.blockedDomains
+    }
+  } : undefined;
+  const search = await client.beta.search({
+    mode: "agentic",
+    objective: options.query,
+    max_results: 10,
+    ...sourcePolicy && { source_policy: sourcePolicy }
+  });
+  return (search.results || []).map((result) => ({
+    title: result.title ?? "",
+    url: result.url ?? "",
+    snippet: result.excerpts?.join(`
+`) ?? "",
+    metadata: result.publish_date ? { publish_date: result.publish_date } : undefined
+  }));
+}
+async function searchContent(apiKey, provider, options) {
+  switch (provider) {
+    case "parallel":
+      return searchWithParallel(apiKey, options);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`Unknown provider: ${_exhaustive}`);
+    }
+  }
+}
 var webSearchInputSchema = z11.object({
   query: z11.string().describe("The search query to use"),
   allowed_domains: z11.array(z11.string()).optional().describe("Only include results from these domains"),
@@ -1513,7 +1615,13 @@ When searching for recent information, documentation, or current events, use the
 - allowed_domains: Only include results from these domains
 - blocked_domains: Never include results from these domains`;
 function createWebSearchTool(config) {
-  const { apiKey, strict, needsApproval, providerOptions } = config;
+  const {
+    provider = "parallel",
+    apiKey,
+    strict,
+    needsApproval,
+    providerOptions
+  } = config;
   return tool11({
     description: WEB_SEARCH_DESCRIPTION,
     inputSchema: zodSchema11(webSearchInputSchema),
@@ -1523,24 +1631,11 @@ function createWebSearchTool(config) {
     execute: async (input) => {
       const { query, allowed_domains, blocked_domains } = input;
       try {
-        const client = new Parallel2({ apiKey });
-        const sourcePolicy = allowed_domains || blocked_domains ? {
-          ...allowed_domains && { include_domains: allowed_domains },
-          ...blocked_domains && { exclude_domains: blocked_domains }
-        } : undefined;
-        const search = await client.beta.search({
-          mode: "agentic",
-          objective: query,
-          max_results: 10,
-          ...sourcePolicy && { source_policy: sourcePolicy }
+        const results = await searchContent(apiKey, provider, {
+          query,
+          allowedDomains: allowed_domains,
+          blockedDomains: blocked_domains
         });
-        const results = (search.results || []).map((result) => ({
-          title: result.title ?? "",
-          url: result.url ?? "",
-          snippet: result.excerpts?.join(`
-`) ?? "",
-          metadata: result.publish_date ? { publish_date: result.publish_date } : undefined
-        }));
         return {
           results,
           total_results: results.length,

package/dist/tools/index.d.ts

@@ -69,7 +69,7 @@ export type { SubagentEventData, SubagentStepEvent, SubagentTypeConfig, TaskErro
 export { createTaskTool } from "./task";
 export type { TodoItem, TodoState, TodoWriteError, TodoWriteOutput, } from "./todo-write";
 export { createTodoWriteTool } from "./todo-write";
-export type { WebFetchError, WebFetchOutput } from "./web-fetch";
+export type { ExtractResult, WebFetchError, WebFetchOutput } from "./web-fetch";
 export { createWebFetchTool } from "./web-fetch";
 export type { WebSearchError, WebSearchOutput, WebSearchResult, } from "./web-search";
 export { createWebSearchTool } from "./web-search";

package/dist/tools/web-fetch.d.ts

@@ -10,6 +10,14 @@ export interface WebFetchError {
     status_code?: number;
     retryable?: boolean;
 }
+/**
+ * Result from a web fetch provider's extract operation.
+ * New providers should return this shape.
+ */
+export interface ExtractResult {
+    content: string;
+    finalUrl?: string;
+}
 export declare function createWebFetchTool(config: WebFetchConfig): import("ai").Tool<{
     url: string;
     prompt: string;

package/dist/types.d.ts

@@ -21,14 +21,27 @@ export type ToolConfig = {
     allowedPaths?: string[];
     blockedCommands?: string[];
 } & SDKToolOptions;
-export type GrepToolConfig = ToolConfig & {
-    /** Use ripgrep (rg) instead of grep. Requires ripgrep to be installed. Default: false */
-    useRipgrep?: boolean;
-};
+export type GrepToolConfig = ToolConfig;
+/**
+ * Supported web search providers.
+ * Currently only 'parallel' is implemented.
+ * Add new providers here as union types (e.g., 'parallel' | 'serper' | 'tavily')
+ */
+export type WebSearchProvider = "parallel";
+/**
+ * Supported web fetch providers.
+ * Currently only 'parallel' is implemented.
+ * Add new providers here as union types (e.g., 'parallel' | 'firecrawl' | 'jina')
+ */
+export type WebFetchProvider = "parallel";
 export type WebSearchConfig = {
+    /** Provider to use for web search. Default: 'parallel' */
+    provider?: WebSearchProvider;
     apiKey: string;
 } & SDKToolOptions;
 export type WebFetchConfig = {
+    /** Provider to use for web fetching. Default: 'parallel' */
+    provider?: WebFetchProvider;
     apiKey: string;
     model: LanguageModel;
 } & SDKToolOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bashkit",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Agentic coding tools for the Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
   "scripts": {
     "dev": "bun run src/index.ts",
     "build": "bun run build:js && bun run build:cli && bun run build:types",
-    "build:js": "bun build src/index.ts --outdir dist --target node --format esm --external ai --external zod --external @ai-sdk/* --external @vercel/sandbox --external @e2b/code-interpreter --external parallel-web",
+    "build:js": "bun build src/index.ts --outdir dist --target node --format esm --external ai --external zod --external @ai-sdk/* --external @vercel/sandbox --external @e2b/code-interpreter --external parallel-web --external @vscode/ripgrep",
     "build:cli": "bun build src/cli/init.ts --outdir dist/cli --target node --format esm --external @clack/prompts && chmod +x dist/cli/init.js",
     "build:types": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
@@ -51,7 +51,8 @@
     "url": "https://github.com/jbreite/bashkit"
   },
   "dependencies": {
-    "@clack/prompts": "^0.7.0"
+    "@clack/prompts": "^0.7.0",
+    "@vscode/ripgrep": "^1.17.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.1",