bashkit 0.1.3 → 0.2.2

package/dist/index.js

@@ -18,10 +18,8 @@ var __toESM = (mod, isNodeMode, target) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/middleware/anthropic-cache.ts
-function ensureCacheMarker(message) {
-  if (!message)
-    return;
-  if (!("content" in message))
+function addCacheMarker(message) {
+  if (!message || !("content" in message))
     return;
   const content = message.content;
   if (!content || !Array.isArray(content))
@@ -36,36 +34,41 @@ function ensureCacheMarker(message) {
     }
   };
 }
+function applyCacheMarkers(params) {
+  const messages = params.prompt;
+  if (!messages || messages.length === 0)
+    return params;
+  addCacheMarker(messages.at(-1));
+  addCacheMarker(messages.slice(0, -1).findLast((m) => m.role !== "assistant"));
+  return params;
+}
+var anthropicPromptCacheMiddlewareV2 = {
+  transformParams: async ({ params }) => applyCacheMarkers(params)
+};
 var anthropicPromptCacheMiddleware = {
-  transformParams: async ({
-    params
-  }) => {
-    const messages = params.prompt;
-    if (!messages || messages.length === 0) {
-      return params;
-    }
-    ensureCacheMarker(messages.at(-1));
-    ensureCacheMarker(messages.slice(0, -1).findLast((m) => m.role !== "assistant"));
-    return {
-      ...params,
-      prompt: messages
-    };
-  }
+  specificationVersion: "v3",
+  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;
   const workingDirectory = config.cwd || "/home/user";
   const timeout = config.timeout ?? 300000;
   const ensureSandbox = async () => {
     if (sandbox)
       return sandbox;
-    sandbox = await E2BSandboxSDK.create({
-      apiKey: config.apiKey,
-      timeoutMs: timeout,
-      metadata: config.metadata
-    });
+    if (config.sandboxId) {
+      sandbox = await E2BSandboxSDK.connect(config.sandboxId);
+    } else {
+      sandbox = await E2BSandboxSDK.create({
+        apiKey: config.apiKey,
+        timeoutMs: timeout,
+        metadata: config.metadata
+      });
+      sandboxId = sandbox.sandboxId;
+    }
     return sandbox;
   };
   const exec = async (command, options) => {
@@ -111,6 +114,9 @@ function createE2BSandbox(config = {}) {
   };
   return {
     exec,
+    get id() {
+      return sandboxId;
+    },
     async readFile(path) {
       const result = await exec(`cat "${path}"`);
       if (result.exitCode !== 0) {
@@ -230,6 +236,7 @@ function createLocalSandbox(config = {}) {
 import { Sandbox as VercelSandboxSDK } from "@vercel/sandbox";
 function createVercelSandbox(config = {}) {
   let sandbox = null;
+  let sandboxId = config.sandboxId;
   const workingDirectory = config.cwd || "/vercel/sandbox";
   const resolvedConfig = {
     runtime: config.runtime ?? "node22",
@@ -250,7 +257,12 @@ function createVercelSandbox(config = {}) {
         token: config.token
       });
     }
-    sandbox = await VercelSandboxSDK.create(createOptions);
+    if (config.sandboxId) {
+      sandbox = await VercelSandboxSDK.get({ sandboxId: config.sandboxId });
+    } else {
+      sandbox = await VercelSandboxSDK.create(createOptions);
+    }
+    sandboxId = sandbox.sandboxId;
     return sandbox;
   };
   const exec = async (command, options) => {
@@ -304,6 +316,9 @@ function createVercelSandbox(config = {}) {
   };
   return {
     exec,
+    get id() {
+      return sandboxId;
+    },
     async readFile(path) {
       const sbx = await ensureSandbox();
       const stream = await sbx.readFile({ path });
@@ -349,6 +364,132 @@ function createVercelSandbox(config = {}) {
     }
   };
 }
+// src/cache/lru.ts
+class LRUCacheStore {
+  cache = new Map;
+  maxSize;
+  constructor(maxSize = 1000) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (entry) {
+      this.cache.delete(key);
+      this.cache.set(key, entry);
+    }
+    return entry;
+  }
+  set(key, entry) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, entry);
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+}
+// src/cache/cached.ts
+import { createHash } from "crypto";
+function defaultKeyGenerator(toolName, params) {
+  const sortedKeys = params && typeof params === "object" ? Object.keys(params).sort() : undefined;
+  const serialized = JSON.stringify(params, sortedKeys);
+  const hash = createHash("sha256").update(serialized).digest("hex").slice(0, 16);
+  return `${toolName}:${hash}`;
+}
+function cached(tool, toolName, options = {}) {
+  const {
+    ttl = 5 * 60 * 1000,
+    store = new LRUCacheStore,
+    keyGenerator = defaultKeyGenerator,
+    debug = false,
+    onHit,
+    onMiss
+  } = options;
+  let hits = 0;
+  let misses = 0;
+  const log = debug ? console.log.bind(console) : () => {};
+  const cachedTool = {
+    ...tool,
+    execute: async (params, execOptions) => {
+      const key = keyGenerator(toolName, params);
+      const now = Date.now();
+      const entry = await store.get(key);
+      if (entry && now - entry.timestamp < ttl) {
+        hits++;
+        log(`[Cache] HIT ${toolName}:${key.slice(-8)}`);
+        onHit?.(toolName, key);
+        return entry.result;
+      }
+      misses++;
+      log(`[Cache] MISS ${toolName}:${key.slice(-8)}`);
+      onMiss?.(toolName, key);
+      if (!tool.execute) {
+        throw new Error(`Tool ${toolName} has no execute function`);
+      }
+      const result = await tool.execute(params, execOptions);
+      if (result && typeof result === "object" && !("error" in result)) {
+        await store.set(key, { result, timestamp: now });
+        log(`[Cache] STORED ${toolName}:${key.slice(-8)}`);
+      }
+      return result;
+    },
+    async getStats() {
+      const total = hits + misses;
+      const size = await store.size?.() ?? 0;
+      return {
+        hits,
+        misses,
+        hitRate: total > 0 ? hits / total : 0,
+        size
+      };
+    },
+    async clearCache(key) {
+      if (key) {
+        await store.delete(key);
+      } else {
+        await store.clear();
+      }
+    }
+  };
+  return cachedTool;
+}
+// src/cache/redis.ts
+function createRedisCacheStore(client, options = {}) {
+  const { prefix = "bashkit:" } = options;
+  return {
+    async get(key) {
+      const data = await client.get(`${prefix}${key}`);
+      return data ? JSON.parse(data) : undefined;
+    },
+    async set(key, entry) {
+      await client.set(`${prefix}${key}`, JSON.stringify(entry));
+    },
+    async delete(key) {
+      await client.del(`${prefix}${key}`);
+    },
+    async clear() {
+      const keys = await client.keys(`${prefix}*`);
+      if (keys.length)
+        await client.del(keys);
+    },
+    async size() {
+      const keys = await client.keys(`${prefix}*`);
+      return keys.length;
+    }
+  };
+}
 // src/types.ts
 var DEFAULT_CONFIG = {
   defaultTimeout: 120000,
@@ -500,6 +641,9 @@ function createBashTool(sandbox, config) {
   return tool2({
     description: BASH_DESCRIPTION,
     inputSchema: zodSchema2(bashInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       command,
       timeout,
@@ -576,6 +720,9 @@ function createEditTool(sandbox, config) {
   return tool3({
     description: EDIT_DESCRIPTION,
     inputSchema: zodSchema3(editInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       file_path,
       old_string,
@@ -750,7 +897,7 @@ Before using this tool, ensure your plan is clear and unambiguous. If there are
 1. "Search for and understand the implementation of X" - Do NOT use this tool (research task)
 2. "Help me implement feature Y" - Use this tool after planning the implementation steps
 3. "Add user authentication" - If unsure about approach (OAuth vs JWT), clarify first, then use this tool`;
-function createExitPlanModeTool(config, onPlanSubmit) {
+function createExitPlanModeTool(onPlanSubmit) {
   return tool5({
     description: EXIT_PLAN_MODE_DESCRIPTION,
     inputSchema: zodSchema5(exitPlanModeInputSchema),
@@ -794,6 +941,9 @@ function createGlobTool(sandbox, config) {
   return tool6({
     description: GLOB_DESCRIPTION,
     inputSchema: zodSchema6(globInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       pattern,
       path
@@ -871,6 +1021,9 @@ function createGrepTool(sandbox, config) {
   return tool7({
     description: GREP_DESCRIPTION,
     inputSchema: zodSchema7(grepInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async (input) => {
       const {
         pattern,
@@ -1080,6 +1233,9 @@ function createReadTool(sandbox, config) {
   return tool8({
     description: READ_DESCRIPTION,
     inputSchema: zodSchema8(readInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       file_path,
       offset,
@@ -1236,11 +1392,15 @@ function createSkillTool(config) {
 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 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")
 });
-var RETRYABLE_CODES = [408, 429, 500, 502, 503];
 var WEB_FETCH_DESCRIPTION = `
 - Fetches content from a specified URL and processes it using an AI model
 - Takes a URL and a prompt as input
@@ -1258,10 +1418,13 @@ 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 } = config;
+  const { apiKey, model, strict, needsApproval, providerOptions } = config;
   return tool10({
     description: WEB_FETCH_DESCRIPTION,
     inputSchema: zodSchema10(webFetchInputSchema),
+    strict,
+    needsApproval,
+    providerOptions,
     execute: async (input) => {
       const { url, prompt } = input;
       try {
@@ -1309,7 +1472,7 @@ ${content}`
           return {
             error: message,
             status_code: statusCode,
-            retryable: RETRYABLE_CODES.includes(statusCode)
+            retryable: RETRYABLE_STATUS_CODES.includes(statusCode)
           };
         }
         return {
@@ -1329,7 +1492,6 @@ var webSearchInputSchema = z11.object({
   allowed_domains: z11.array(z11.string()).optional().describe("Only include results from these domains"),
   blocked_domains: z11.array(z11.string()).optional().describe("Never include results from these domains")
 });
-var RETRYABLE_CODES2 = [408, 429, 500, 502, 503];
 var WEB_SEARCH_DESCRIPTION = `Searches the web and returns results with links. Use this for accessing up-to-date information beyond your knowledge cutoff.
 
 **Capabilities:**
@@ -1351,10 +1513,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 } = config;
+  const { apiKey, strict, needsApproval, providerOptions } = config;
   return tool11({
     description: WEB_SEARCH_DESCRIPTION,
     inputSchema: zodSchema11(webSearchInputSchema),
+    strict,
+    needsApproval,
+    providerOptions,
     execute: async (input) => {
       const { query, allowed_domains, blocked_domains } = input;
       try {
@@ -1388,7 +1553,7 @@ function createWebSearchTool(config) {
           return {
             error: message,
             status_code: statusCode,
-            retryable: RETRYABLE_CODES2.includes(statusCode)
+            retryable: RETRYABLE_STATUS_CODES.includes(statusCode)
           };
         }
         return {
@@ -1422,6 +1587,9 @@ function createWriteTool(sandbox, config) {
   return tool12({
     description: WRITE_DESCRIPTION,
     inputSchema: zodSchema12(writeInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       file_path,
       content
@@ -1465,13 +1633,17 @@ import { z as z13 } from "zod";
 var taskInputSchema = z13.object({
   description: z13.string().describe("A short (3-5 word) description of the task"),
   prompt: z13.string().describe("The task for the agent to perform"),
-  subagent_type: z13.string().describe("The type of specialized agent to use for this task")
+  subagent_type: z13.string().describe("The type of specialized agent to use for this task"),
+  system_prompt: z13.string().optional().describe("Optional custom system prompt for this agent. If provided, overrides the default system prompt for the subagent type. Use this to create dynamic, specialized agents on the fly."),
+  tools: z13.array(z13.string()).optional().describe("Optional list of tool names this agent can use (e.g., ['Read', 'Grep', 'WebSearch']). If provided, overrides the default tools for the subagent type. Use this to restrict or expand the agent's capabilities.")
 });
 var TASK_DESCRIPTION = `Launch a new agent to handle complex, multi-step tasks autonomously.
 
 The Task tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
 
-When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+**Subagent types:**
+- Use predefined subagent_type values for common task patterns
+- For dynamic agents: provide custom system_prompt and/or tools to create a specialized agent on the fly
 
 **When NOT to use the Task tool:**
 - If you want to read a specific file path, use the Read or Glob tool instead, to find the match more quickly
@@ -1517,14 +1689,16 @@ function createTaskTool(config) {
     execute: async ({
       description,
       prompt,
-      subagent_type
+      subagent_type,
+      system_prompt,
+      tools: customTools
     }) => {
       const startTime = performance.now();
       try {
         const typeConfig = subagentTypes[subagent_type] || {};
         const model = typeConfig.model || defaultModel;
-        const tools = filterTools(allTools, typeConfig.tools);
-        const systemPrompt = typeConfig.systemPrompt;
+        const tools = filterTools(allTools, customTools ?? typeConfig.tools);
+        const systemPrompt = system_prompt ?? typeConfig.systemPrompt;
         const commonOptions = {
           model,
           tools,
@@ -1677,7 +1851,7 @@ var TODO_WRITE_DESCRIPTION = `Use this tool to create and manage a structured ta
 - Keep exactly ONE task in_progress at any time
 - ONLY mark completed when FULLY accomplished
 - If blocked/errors, keep in_progress and create new task for the blocker`;
-function createTodoWriteTool(state, config, onUpdate) {
+function createTodoWriteTool(state, onUpdate) {
   return tool14({
     description: TODO_WRITE_DESCRIPTION,
     inputSchema: zodSchema14(todoWriteInputSchema),
@@ -1709,6 +1883,58 @@ function createTodoWriteTool(state, config, onUpdate) {
 }
 
 // src/tools/index.ts
+var DEFAULT_CACHEABLE = [
+  "Read",
+  "Glob",
+  "Grep",
+  "WebFetch",
+  "WebSearch"
+];
+function resolveCache(config) {
+  if (!config) {
+    return { store: null, ttl: 0, debug: false, enabled: new Set };
+  }
+  if (config === true) {
+    return {
+      store: new LRUCacheStore,
+      ttl: 5 * 60 * 1000,
+      debug: false,
+      enabled: new Set(DEFAULT_CACHEABLE)
+    };
+  }
+  if (typeof config === "object" && typeof config.get === "function" && typeof config.set === "function" && typeof config.delete === "function" && typeof config.clear === "function") {
+    return {
+      store: config,
+      ttl: 5 * 60 * 1000,
+      debug: false,
+      enabled: new Set(DEFAULT_CACHEABLE)
+    };
+  }
+  const enabled = new Set;
+  for (const tool15 of DEFAULT_CACHEABLE) {
+    if (config[tool15] !== false) {
+      enabled.add(tool15);
+    }
+  }
+  for (const [key, value] of Object.entries(config)) {
+    if (["store", "ttl", "debug", "onHit", "onMiss", "keyGenerator"].includes(key))
+      continue;
+    if (value === true)
+      enabled.add(key);
+    if (value === false)
+      enabled.delete(key);
+  }
+  const cfg = config;
+  return {
+    store: cfg.store ?? new LRUCacheStore,
+    ttl: cfg.ttl ?? 5 * 60 * 1000,
+    debug: cfg.debug ?? false,
+    onHit: cfg.onHit,
+    onMiss: cfg.onMiss,
+    keyGenerator: cfg.keyGenerator,
+    enabled
+  };
+}
 function createAgentTools(sandbox, config) {
   const toolsConfig = {
     ...DEFAULT_CONFIG.tools,
@@ -1744,6 +1970,21 @@ function createAgentTools(sandbox, config) {
   if (config?.webFetch) {
     tools.WebFetch = createWebFetchTool(config.webFetch);
   }
+  const cacheConfig = resolveCache(config?.cache);
+  if (cacheConfig.store) {
+    for (const [name, tool15] of Object.entries(tools)) {
+      if (cacheConfig.enabled.has(name)) {
+        tools[name] = cached(tool15, name, {
+          store: cacheConfig.store,
+          ttl: cacheConfig.ttl,
+          debug: cacheConfig.debug,
+          onHit: cacheConfig.onHit,
+          onMiss: cacheConfig.onMiss,
+          keyGenerator: cacheConfig.keyGenerator
+        });
+      }
+    }
+  }
   return { tools, planModeState };
 }
 // src/utils/compact-conversation.ts
@@ -2097,11 +2338,13 @@ function contextNeedsCompaction(status) {
   return status.status === "critical";
 }
 // src/skills/discovery.ts
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile2, stat } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join as join2, resolve } from "node:path";
 
 // src/skills/loader.ts
+import { readdir, readFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 function parseSkillMetadata(content, skillPath) {
   const frontmatter = extractFrontmatter(content);
   if (!frontmatter) {
@@ -2190,6 +2433,32 @@ function parseYaml(yaml) {
   }
   return result;
 }
+async function loadSkillBundle(skillDir) {
+  const files = {};
+  const name = basename(skillDir);
+  async function readDirRecursive(dir, prefix = "") {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await readDirRecursive(fullPath, relativePath);
+      } else {
+        files[relativePath] = await readFile(fullPath, "utf-8");
+      }
+    }
+  }
+  await readDirRecursive(skillDir);
+  return { name, files };
+}
+async function loadSkillBundles(skills) {
+  const bundles = {};
+  for (const skill of skills) {
+    const skillDir = dirname(skill.path);
+    bundles[skill.name] = await loadSkillBundle(skillDir);
+  }
+  return bundles;
+}
 
 // src/skills/discovery.ts
 var DEFAULT_SKILL_PATHS = [".skills", "~/.bashkit/skills"];
@@ -2212,7 +2481,7 @@ async function discoverSkills(options) {
 }
 function resolvePath(path, cwd) {
   if (path.startsWith("~/")) {
-    return join(homedir(), path.slice(2));
+    return join2(homedir(), path.slice(2));
   }
   if (path.startsWith("/")) {
     return path;
@@ -2222,18 +2491,18 @@ function resolvePath(path, cwd) {
 async function scanDirectory(dirPath) {
   const skills = [];
   try {
-    const entries = await readdir(dirPath, { withFileTypes: true });
+    const entries = await readdir2(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const skillPath = join(dirPath, entry.name, "SKILL.md");
+      const skillPath = join2(dirPath, entry.name, "SKILL.md");
       try {
         const skillStat = await stat(skillPath);
         if (!skillStat.isFile()) {
           continue;
         }
-        const content = await readFile(skillPath, "utf-8");
+        const content = await readFile2(skillPath, "utf-8");
         const metadata = parseSkillMetadata(content, skillPath);
         if (metadata.name !== entry.name) {
           console.warn(`Skill name "${metadata.name}" does not match folder name "${entry.name}" in ${skillPath}`);
@@ -2406,6 +2675,8 @@ export {
   setupAgentEnvironment,
   pruneMessagesByTokens,
   parseSkillMetadata,
+  loadSkillBundles,
+  loadSkillBundle,
   getContextStatus,
   fetchSkills,
   fetchSkill,
@@ -2420,6 +2691,7 @@ export {
   createTodoWriteTool,
   createTaskTool,
   createSkillTool,
+  createRedisCacheStore,
   createReadTool,
   createLocalSandbox,
   createGrepTool,
@@ -2435,7 +2707,10 @@ export {
   contextNeedsCompaction,
   contextNeedsAttention,
   compactConversation,
+  cached,
+  anthropicPromptCacheMiddlewareV2,
   anthropicPromptCacheMiddleware,
   MODEL_CONTEXT_LIMITS,
+  LRUCacheStore,
   DEFAULT_CONFIG
 };

package/dist/middleware/anthropic-cache.d.ts

@@ -1,6 +1,25 @@
 import type { LanguageModelV2Middleware } from "@ai-sdk/provider";
+import type { LanguageModelMiddleware } from "ai";
 /**
  * Middleware that enables Anthropic's prompt caching feature.
+ * For AI SDK v5 (LanguageModelV2).
+ *
+ * @example
+ * ```typescript
+ * import { wrapLanguageModel } from 'ai';
+ * import { anthropic } from '@ai-sdk/anthropic';
+ * import { anthropicPromptCacheMiddlewareV2 } from 'bashkit';
+ *
+ * const model = wrapLanguageModel({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   middleware: anthropicPromptCacheMiddlewareV2,
+ * });
+ * ```
+ */
+export declare const anthropicPromptCacheMiddlewareV2: LanguageModelV2Middleware;
+/**
+ * Middleware that enables Anthropic's prompt caching feature.
+ * For AI SDK v6+ (LanguageModelV3).
  *
  * @example
  * ```typescript
@@ -14,4 +33,4 @@ import type { LanguageModelV2Middleware } from "@ai-sdk/provider";
  * });
  * ```
  */
-export declare const anthropicPromptCacheMiddleware: LanguageModelV2Middleware;
+export declare const anthropicPromptCacheMiddleware: LanguageModelMiddleware;

package/dist/middleware/index.d.ts

@@ -1 +1 @@
-export { anthropicPromptCacheMiddleware } from "./anthropic-cache";
+export { anthropicPromptCacheMiddleware, anthropicPromptCacheMiddlewareV2, } from "./anthropic-cache";

package/dist/sandbox/e2b.d.ts

@@ -1,6 +1,8 @@
 import type { Sandbox } from "./interface";
 export interface E2BSandboxConfig {
     apiKey?: string;
+    /** Existing sandbox ID to reconnect to instead of creating new */
+    sandboxId?: string;
     template?: string;
     timeout?: number;
     cwd?: string;

package/dist/sandbox/interface.d.ts

@@ -18,4 +18,11 @@ export interface Sandbox {
     fileExists(path: string): Promise<boolean>;
     isDirectory(path: string): Promise<boolean>;
     destroy(): Promise<void>;
+    /**
+     * Sandbox ID for reconnection (cloud providers only).
+     * - For new sandboxes: available after first operation
+     * - For reconnected sandboxes: available immediately
+     * - For local sandboxes: always undefined
+     */
+    readonly id?: string;
 }

package/dist/sandbox/vercel.d.ts

@@ -4,6 +4,8 @@ export interface VercelSandboxConfig {
     resources?: {
         vcpus: number;
     };
+    /** Existing sandbox ID to reconnect to instead of creating new */
+    sandboxId?: string;
     timeout?: number;
     cwd?: string;
     teamId?: string;

package/dist/skills/index.d.ts

@@ -2,5 +2,5 @@ export type { DiscoverSkillsOptions, SkillMetadata } from "./types";
 export type { SkillBundle } from "./fetch";
 export { discoverSkills } from "./discovery";
 export { fetchSkill, fetchSkills } from "./fetch";
-export { parseSkillMetadata } from "./loader";
+export { parseSkillMetadata, loadSkillBundle, loadSkillBundles, } from "./loader";
 export { skillsToXml } from "./xml";