bashkit 0.1.3 → 0.2.1

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,21 +34,20 @@ 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";
@@ -349,6 +346,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 +623,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 +702,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 +879,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 +923,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 +1003,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 +1215,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 +1374,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 +1400,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 +1454,7 @@ ${content}`
           return {
             error: message,
             status_code: statusCode,
-            retryable: RETRYABLE_CODES.includes(statusCode)
+            retryable: RETRYABLE_STATUS_CODES.includes(statusCode)
           };
         }
         return {
@@ -1329,7 +1474,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 +1495,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 +1535,7 @@ function createWebSearchTool(config) {
           return {
             error: message,
             status_code: statusCode,
-            retryable: RETRYABLE_CODES2.includes(statusCode)
+            retryable: RETRYABLE_STATUS_CODES.includes(statusCode)
           };
         }
         return {
@@ -1422,6 +1569,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 +1615,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 +1671,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 +1833,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 +1865,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 +1952,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 +2320,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 +2415,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 +2463,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 +2473,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 +2657,8 @@ export {
   setupAgentEnvironment,
   pruneMessagesByTokens,
   parseSkillMetadata,
+  loadSkillBundles,
+  loadSkillBundle,
   getContextStatus,
   fetchSkills,
   fetchSkill,
@@ -2420,6 +2673,7 @@ export {
   createTodoWriteTool,
   createTaskTool,
   createSkillTool,
+  createRedisCacheStore,
   createReadTool,
   createLocalSandbox,
   createGrepTool,
@@ -2435,7 +2689,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/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";

package/dist/skills/loader.d.ts

@@ -1,3 +1,4 @@
+import type { SkillBundle } from "./fetch";
 import type { SkillMetadata } from "./types";
 /**
  * Parses YAML frontmatter from a SKILL.md file content.
@@ -9,3 +10,38 @@ import type { SkillMetadata } from "./types";
  * @throws Error if required fields (name, description) are missing
  */
 export declare function parseSkillMetadata(content: string, skillPath: string): SkillMetadata;
+/**
+ * Loads all files from a local skill directory as a SkillBundle.
+ * Recursively reads all files, preserving directory structure.
+ *
+ * @param skillDir - Absolute path to skill directory (containing SKILL.md)
+ * @returns SkillBundle with all files
+ *
+ * @example
+ * ```typescript
+ * const bundle = await loadSkillBundle('/path/to/.skills/pdf-processing');
+ * // bundle.files = {
+ * //   'SKILL.md': '---\nname: pdf-processing\n...',
+ * //   'templates/report.md': '# Report Template...',
+ * //   'scripts/extract.sh': '#!/bin/bash...',
+ * // }
+ * ```
+ */
+export declare function loadSkillBundle(skillDir: string): Promise<SkillBundle>;
+/**
+ * Loads multiple discovered skills as bundles.
+ * Takes the output of discoverSkills() and loads all files for each skill.
+ *
+ * @param skills - Array of skill metadata from discoverSkills()
+ * @returns Record mapping skill names to their bundles
+ *
+ * @example
+ * ```typescript
+ * const discovered = await discoverSkills();
+ * const bundles = await loadSkillBundles(discovered);
+ *
+ * // Use with setupAgentEnvironment
+ * await setupAgentEnvironment(sandbox, { skills: bundles });
+ * ```
+ */
+export declare function loadSkillBundles(skills: SkillMetadata[]): Promise<Record<string, SkillBundle>>;

package/dist/tools/exit-plan-mode.d.ts

@@ -1,4 +1,3 @@
-import type { ToolConfig } from "../types";
 export interface ExitPlanModeOutput {
     message: string;
     approved?: boolean;
@@ -6,6 +5,6 @@ export interface ExitPlanModeOutput {
 export interface ExitPlanModeError {
     error: string;
 }
-export declare function createExitPlanModeTool(config?: ToolConfig, onPlanSubmit?: (plan: string) => Promise<boolean> | boolean): import("ai").Tool<{
+export declare function createExitPlanModeTool(onPlanSubmit?: (plan: string) => Promise<boolean> | boolean): import("ai").Tool<{
     plan: string;
 }, ExitPlanModeOutput | ExitPlanModeError>;

package/dist/tools/index.d.ts

@@ -69,9 +69,9 @@ 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, WebFetchToolConfig, } from "./web-fetch";
+export type { WebFetchError, WebFetchOutput } from "./web-fetch";
 export { createWebFetchTool } from "./web-fetch";
-export type { WebSearchError, WebSearchOutput, WebSearchResult, WebSearchToolConfig, } from "./web-search";
+export type { WebSearchError, WebSearchOutput, WebSearchResult, } from "./web-search";
 export { createWebSearchTool } from "./web-search";
 export type { WriteError, WriteOutput } from "./write";
 export { createWriteTool } from "./write";

package/dist/tools/task.d.ts

@@ -1,4 +1,5 @@
 import { type ModelMessage, type LanguageModel, type PrepareStepFunction, type StepResult, type StopCondition, type UIMessageStreamWriter, type Tool, type ToolSet } from "ai";
+import { z } from "zod";
 export interface TaskOutput {
     result: string;
     usage?: {
@@ -12,6 +13,14 @@ export interface TaskOutput {
 export interface TaskError {
     error: string;
 }
+declare const taskInputSchema: z.ZodObject<{
+    description: z.ZodString;
+    prompt: z.ZodString;
+    subagent_type: z.ZodString;
+    system_prompt: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type TaskInput = z.infer<typeof taskInputSchema>;
 /** Event emitted for each step a subagent takes */
 export interface SubagentStepEvent {
     subagentType: string;
@@ -55,4 +64,5 @@ export interface TaskToolConfig {
     /** Optional stream writer for real-time subagent activity (uses streamText instead of generateText) */
     streamWriter?: UIMessageStreamWriter;
 }
-export declare function createTaskTool(config: TaskToolConfig): Tool;
+export declare function createTaskTool(config: TaskToolConfig): Tool<TaskInput, TaskOutput | TaskError>;
+export {};