bashkit 0.1.2 → 0.2.1

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/ask-user.d.ts

@@ -1,23 +1,53 @@
-export interface AskUserOutput {
+export interface QuestionOption {
+    label: string;
+    description?: string;
+}
+export interface StructuredQuestion {
+    header?: string;
+    question: string;
+    options?: QuestionOption[];
+    multiSelect?: boolean;
+}
+export interface AskUserSimpleOutput {
     question: string;
     awaiting_response: true;
 }
+export interface AskUserStructuredOutput {
+    questions: StructuredQuestion[];
+    awaiting_response: true;
+}
+export type AskUserOutput = AskUserSimpleOutput | AskUserStructuredOutput;
 export interface AskUserError {
     error: string;
 }
+export interface AskUserAnswerOutput {
+    answer: string;
+    answers?: Record<string, string | string[]>;
+}
 export type AskUserResponseHandler = (question: string) => Promise<string> | string;
+export type AskUserStructuredHandler = (questions: StructuredQuestion[]) => Promise<Record<string, string | string[]>> | Record<string, string | string[]>;
+export interface AskUserToolConfig {
+    /** Handler for simple string questions */
+    onQuestion?: AskUserResponseHandler;
+    /** Handler for structured questions with options */
+    onStructuredQuestions?: AskUserStructuredHandler;
+}
 /**
  * Creates a tool for asking the user clarifying questions.
  *
- * The response handler can be:
- * - Synchronous: returns the answer immediately
- * - Async: waits for user input (e.g., from a UI)
- * - Undefined: tool returns awaiting_response flag for external handling
+ * Supports both simple string questions and structured multi-choice questions.
  *
- * @param onQuestion - Optional callback to handle the question and return an answer
+ * @param config - Configuration with optional handlers for questions
  */
-export declare function createAskUserTool(onQuestion?: AskUserResponseHandler): import("ai").Tool<{
-    question: string;
-}, AskUserOutput | AskUserError | {
-    answer: string;
-}>;
+export declare function createAskUserTool(config?: AskUserToolConfig | AskUserResponseHandler): import("ai").Tool<{
+    question?: string | undefined;
+    questions?: {
+        question: string;
+        header?: string | undefined;
+        options?: {
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        multiSelect?: boolean | undefined;
+    }[] | undefined;
+}, AskUserOutput | AskUserError | AskUserAnswerOutput>;

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/grep.d.ts

@@ -1,5 +1,5 @@
 import type { Sandbox } from "../sandbox/interface";
-import type { ToolConfig } from "../types";
+import type { GrepToolConfig } from "../types";
 export interface GrepMatch {
     file: string;
     line_number?: number;
@@ -26,7 +26,7 @@ export interface GrepError {
     error: string;
 }
 export type GrepOutput = GrepContentOutput | GrepFilesOutput | GrepCountOutput | GrepError;
-export declare function createGrepTool(sandbox: Sandbox, config?: ToolConfig): import("ai").Tool<{
+export declare function createGrepTool(sandbox: Sandbox, config?: GrepToolConfig): import("ai").Tool<{
     pattern: string;
     path?: string | undefined;
     glob?: string | undefined;
@@ -38,5 +38,6 @@ export declare function createGrepTool(sandbox: Sandbox, config?: ToolConfig): i
     "-A"?: number | undefined;
     "-C"?: number | undefined;
     head_limit?: number | undefined;
+    offset?: number | undefined;
     multiline?: boolean | undefined;
 }, GrepOutput>;

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 {};

package/dist/tools/todo-write.d.ts

@@ -1,4 +1,3 @@
-import type { ToolConfig } from "../types";
 export interface TodoItem {
     content: string;
     status: "pending" | "in_progress" | "completed";
@@ -19,7 +18,7 @@ export interface TodoWriteError {
 export interface TodoState {
     todos: TodoItem[];
 }
-export declare function createTodoWriteTool(state: TodoState, config?: ToolConfig, onUpdate?: (todos: TodoItem[]) => void): import("ai").Tool<{
+export declare function createTodoWriteTool(state: TodoState, onUpdate?: (todos: TodoItem[]) => void): import("ai").Tool<{
     todos: {
         content: string;
         status: "pending" | "in_progress" | "completed";

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

@@ -0,0 +1,5 @@
+/**
+ * HTTP status codes that indicate a retryable error.
+ * Shared between web-search and web-fetch tools.
+ */
+export declare const RETRYABLE_STATUS_CODES: number[];

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

@@ -1,4 +1,4 @@
-import type { LanguageModel } from "ai";
+import type { WebFetchConfig } from "../types";
 export interface WebFetchOutput {
     response: string;
     url: string;
@@ -10,11 +10,7 @@ export interface WebFetchError {
     status_code?: number;
     retryable?: boolean;
 }
-export interface WebFetchToolConfig {
-    apiKey: string;
-    model: LanguageModel;
-}
-export declare function createWebFetchTool(config: WebFetchToolConfig): import("ai").Tool<{
+export declare function createWebFetchTool(config: WebFetchConfig): import("ai").Tool<{
     url: string;
     prompt: string;
 }, WebFetchOutput | WebFetchError>;

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

@@ -1,3 +1,4 @@
+import type { WebSearchConfig } from "../types";
 export interface WebSearchResult {
     title: string;
     url: string;
@@ -14,10 +15,7 @@ export interface WebSearchError {
     status_code?: number;
     retryable?: boolean;
 }
-export interface WebSearchToolConfig {
-    apiKey: string;
-}
-export declare function createWebSearchTool(config: WebSearchToolConfig): import("ai").Tool<{
+export declare function createWebSearchTool(config: WebSearchConfig): import("ai").Tool<{
     query: string;
     allowed_domains?: string[] | undefined;
     blocked_domains?: string[] | undefined;

package/dist/types.d.ts

@@ -1,19 +1,37 @@
-import type { LanguageModel } from "ai";
+import type { LanguageModel, Tool } from "ai";
+import type { CacheStore } from "./cache/types";
 import type { SkillMetadata } from "./skills/types";
+/**
+ * SDK tool options picked from the Tool type.
+ * This automatically adapts to the user's installed AI SDK version.
+ * - v5 users get v5 options (if any)
+ * - v6 users get v6 options (needsApproval, strict, etc.)
+ *
+ * Uses `any` for input/output to allow typed needsApproval functions.
+ */
+export type SDKToolOptions = Partial<Pick<Tool<any, any>, "strict" | "needsApproval" | "providerOptions">>;
+/**
+ * Configuration for sandbox-based tools.
+ * Extends AI SDK tool options for version-appropriate type safety.
+ */
 export type ToolConfig = {
     timeout?: number;
     maxFileSize?: number;
     maxOutputLength?: number;
     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 WebSearchConfig = {
     apiKey: string;
-};
+} & SDKToolOptions;
 export type WebFetchConfig = {
     apiKey: string;
     model: LanguageModel;
-};
+} & SDKToolOptions;
 export type AskUserConfig = {
     /** Callback to handle questions and return answers */
     onQuestion?: (question: string) => Promise<string> | string;
@@ -24,6 +42,40 @@ export type SkillConfig = {
     /** Callback when a skill is activated */
     onActivate?: (skill: SkillMetadata, instructions: string) => void | Promise<void>;
 };
+/**
+ * Cache configuration for tool result caching.
+ *
+ * @example
+ * ```typescript
+ * // Enable with defaults (LRU cache, 5min TTL, safe tools only)
+ * cache: true
+ *
+ * // Custom cache store
+ * cache: myRedisStore
+ *
+ * // Per-tool control
+ * cache: { Read: true, Glob: true, Bash: false }
+ *
+ * // Full options
+ * cache: { store: myStore, ttl: 600000, debug: true, Read: true }
+ * ```
+ */
+export type CacheConfig = boolean | CacheStore | {
+    /** Custom cache store (default: LRUCacheStore) */
+    store?: CacheStore;
+    /** TTL in milliseconds (default: 5 minutes) */
+    ttl?: number;
+    /** Enable debug logging for cache hits/misses */
+    debug?: boolean;
+    /** Callback when cache hit occurs */
+    onHit?: (toolName: string, key: string) => void;
+    /** Callback when cache miss occurs */
+    onMiss?: (toolName: string, key: string) => void;
+    /** Custom key generator for cache keys */
+    keyGenerator?: (toolName: string, params: unknown) => string;
+    /** Per-tool overrides - any tool name can be enabled/disabled */
+    [toolName: string]: boolean | CacheStore | number | ((toolName: string, key: string) => void) | ((toolName: string, params: unknown) => string) | undefined;
+};
 export type AgentConfig = {
     tools?: {
         Bash?: ToolConfig;
@@ -31,7 +83,7 @@ export type AgentConfig = {
         Write?: ToolConfig;
         Edit?: ToolConfig;
         Glob?: ToolConfig;
-        Grep?: ToolConfig;
+        Grep?: GrepToolConfig;
     };
     /** Include AskUser tool for user clarification */
     askUser?: AskUserConfig;
@@ -43,6 +95,8 @@ export type AgentConfig = {
     webSearch?: WebSearchConfig;
     /** Include WebFetch tool with this config */
     webFetch?: WebFetchConfig;
+    /** Enable tool result caching */
+    cache?: CacheConfig;
     defaultTimeout?: number;
     workingDirectory?: string;
 };

package/dist/utils/http-constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * HTTP status codes that indicate a retryable error.
+ * Shared between web-search and web-fetch tools.
+ */
+export declare const RETRYABLE_STATUS_CODES: number[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bashkit",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Agentic coding tools for the Vercel AI SDK",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,17 +54,18 @@
     "@clack/prompts": "^0.7.0"
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "^2.0.50",
+    "@ai-sdk/anthropic": "^3.0.1",
     "@biomejs/biome": "^2.3.9",
     "@e2b/code-interpreter": "^1.5.1",
     "@types/bun": "latest",
     "@types/node": "^24.10.0",
     "@vercel/sandbox": "^1.0.4",
+    "ai": "^6.0.0",
     "parallel-web": "^0.2.4",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "ai": "^5.0.0",
+    "ai": ">=5.0.0",
     "zod": "^4.1.8",
     "@vercel/sandbox": "^1.0.0",
     "@e2b/code-interpreter": "^1.0.0",