bashkit 0.1.2 → 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,
@@ -361,10 +484,27 @@ var DEFAULT_CONFIG = {
 // src/tools/ask-user.ts
 import { tool, zodSchema } from "ai";
 import { z } from "zod";
+var questionOptionSchema = z.object({
+  label: z.string().describe("The display text for this option. Should be concise (1-5 words). Add '(Recommended)' suffix for suggested options."),
+  description: z.string().optional().describe("Explanation of what this option means or its implications.")
+});
+var structuredQuestionSchema = z.object({
+  header: z.string().optional().describe("Very short label displayed as a chip/tag (max 12 chars). Examples: 'Auth method', 'Library', 'Approach'."),
+  question: z.string().describe("The complete question to ask the user. Should be clear and specific."),
+  options: z.array(questionOptionSchema).min(2).max(4).optional().describe("Available choices for this question. 2-4 options. An 'Other' option is automatically available to users."),
+  multiSelect: z.boolean().optional().describe("Set to true to allow the user to select multiple options instead of just one.")
+});
 var askUserInputSchema = z.object({
-  question: z.string().describe("The question to ask the user. Be specific and concise.")
+  question: z.string().optional().describe("Simple question string (for backward compatibility). Use 'questions' for structured multi-choice."),
+  questions: z.array(structuredQuestionSchema).min(1).max(4).optional().describe("Structured questions with options (1-4 questions).")
 });
-var ASK_USER_DESCRIPTION = `Ask the user a clarifying question when you need more information to proceed.
+var ASK_USER_DESCRIPTION = `Use this tool when you need to ask the user questions during execution.
+
+**Capabilities:**
+- Gather user preferences or requirements
+- Clarify ambiguous instructions
+- Get decisions on implementation choices
+- Offer choices about what direction to take
 
 **When to use:**
 - You need clarification on ambiguous requirements
@@ -377,23 +517,54 @@ var ASK_USER_DESCRIPTION = `Ask the user a clarifying question when you need mor
 - The question is trivial or can be inferred
 - You're just being overly cautious
 
-Keep questions specific and actionable. Avoid yes/no questions when you need details.`;
-function createAskUserTool(onQuestion) {
+**Simple question format:**
+Use the 'question' parameter for a single free-form question.
+
+**Structured questions format:**
+Use the 'questions' parameter for multiple-choice questions with options:
+- 1-4 questions allowed
+- Each question can have 2-4 options with labels and descriptions
+- Use multiSelect: true to allow multiple answers
+- Users can always select "Other" to provide custom text input
+- Place recommended option first and add "(Recommended)" to label`;
+function createAskUserTool(config) {
+  const normalizedConfig = typeof config === "function" ? { onQuestion: config } : config ?? {};
   return tool({
     description: ASK_USER_DESCRIPTION,
     inputSchema: zodSchema(askUserInputSchema),
-    execute: async ({
-      question
-    }) => {
+    execute: async (input) => {
       try {
-        if (onQuestion) {
-          const answer = await onQuestion(question);
-          return { answer };
+        if (!input.question && !input.questions) {
+          return {
+            error: "Either 'question' or 'questions' must be provided"
+          };
         }
-        return {
-          question,
-          awaiting_response: true
-        };
+        if (input.questions && input.questions.length > 0) {
+          if (normalizedConfig.onStructuredQuestions) {
+            const answers = await normalizedConfig.onStructuredQuestions(input.questions);
+            const firstKey = Object.keys(answers)[0];
+            const firstAnswer = answers[firstKey];
+            return {
+              answer: Array.isArray(firstAnswer) ? firstAnswer.join(", ") : firstAnswer,
+              answers
+            };
+          }
+          return {
+            questions: input.questions,
+            awaiting_response: true
+          };
+        }
+        if (input.question) {
+          if (normalizedConfig.onQuestion) {
+            const answer = await normalizedConfig.onQuestion(input.question);
+            return { answer };
+          }
+          return {
+            question: input.question,
+            awaiting_response: true
+          };
+        }
+        return { error: "No question provided" };
       } catch (error) {
         return {
           error: error instanceof Error ? error.message : "Unknown error"
@@ -412,21 +583,49 @@ var bashInputSchema = z2.object({
   description: z2.string().optional().describe("Clear, concise description of what this command does in 5-10 words"),
   run_in_background: z2.boolean().optional().describe("Set to true to run this command in the background")
 });
-var BASH_DESCRIPTION = `Executes bash commands in a persistent shell session with optional timeout and background execution.
+var BASH_DESCRIPTION = `Executes a bash command in a persistent shell session with optional timeout.
 
-**Important guidelines:**
-- Always quote file paths containing spaces with double quotes (e.g., cd "/path/with spaces")
-- Avoid using search commands like \`find\` and \`grep\` - use the Glob and Grep tools instead
-- Avoid using \`cat\`, \`head\`, \`tail\` - use the Read tool instead
-- When issuing multiple commands, use \`;\` or \`&&\` to separate them (not newlines)
-- If output exceeds 30000 characters, it will be truncated
-- Default timeout is 2 minutes; maximum is 10 minutes`;
+IMPORTANT: For file operations (reading, writing, editing, searching, finding files) - use the specialized tools instead of bash commands.
+
+Before executing the command, please follow these steps:
+
+1. Directory Verification:
+   - If the command will create new directories or files, first use \`ls\` to verify the parent directory exists and is the correct location
+   - For example, before running "mkdir foo/bar", first use \`ls foo\` to check that "foo" exists
+
+2. Command Execution:
+   - Always quote file paths that contain spaces with double quotes (e.g., cd "/path/with spaces")
+   - Examples of proper quoting:
+     - cd "/Users/name/My Documents" (correct)
+     - cd /Users/name/My Documents (incorrect - will fail)
+   - After ensuring proper quoting, execute the command
+
+Usage notes:
+  - The command argument is required
+  - You can specify an optional timeout in milliseconds (max 600000ms / 10 minutes). Default is 120000ms (2 minutes).
+  - It is very helpful if you write a clear, concise description of what this command does in 5-10 words
+  - If the output exceeds 30000 characters, output will be truncated
+  - Avoid using \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands. Instead, use dedicated tools:
+    - File search: Use Glob (NOT find or ls)
+    - Content search: Use Grep (NOT grep or rg)
+    - Read files: Use Read (NOT cat/head/tail)
+    - Edit files: Use Edit (NOT sed/awk)
+    - Write files: Use Write (NOT echo >/cat <<EOF)
+  - When issuing multiple commands:
+    - If commands are independent, make multiple Bash tool calls in parallel
+    - If commands depend on each other, use '&&' to chain them (e.g., \`git add . && git commit -m "message"\`)
+    - Use ';' only when you need sequential execution but don't care if earlier commands fail
+    - DO NOT use newlines to separate commands
+  - Try to maintain your current working directory by using absolute paths and avoiding \`cd\``;
 function createBashTool(sandbox, config) {
   const maxOutputLength = config?.maxOutputLength ?? 30000;
   const defaultTimeout = config?.timeout ?? 120000;
   return tool2({
     description: BASH_DESCRIPTION,
     inputSchema: zodSchema2(bashInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       command,
       timeout,
@@ -482,10 +681,30 @@ var editInputSchema = z3.object({
   new_string: z3.string().describe("The text to replace it with (must be different from old_string)"),
   replace_all: z3.boolean().optional().describe("Replace all occurrences of old_string (default false)")
 });
+var EDIT_DESCRIPTION = `Performs exact string replacements in files.
+
+**Important guidelines:**
+- You MUST use the Read tool first before editing any file
+- Preserve exact indentation (tabs/spaces) when replacing text
+- The old_string must be unique in the file, or the edit will fail
+- If old_string appears multiple times, either provide more context to make it unique, or use replace_all=true
+
+**Parameters:**
+- old_string: The exact text to find and replace (must match exactly, including whitespace)
+- new_string: The replacement text (must be different from old_string)
+- replace_all: Set to true to replace all occurrences (useful for renaming variables)
+
+**When to use:**
+- Making targeted changes to existing files
+- Renaming variables or functions (with replace_all=true)
+- Updating specific sections`;
 function createEditTool(sandbox, config) {
   return tool3({
-    description: "Performs exact string replacements in files.",
+    description: EDIT_DESCRIPTION,
     inputSchema: zodSchema3(editInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       file_path,
       old_string,
@@ -546,24 +765,61 @@ import { z as z4 } from "zod";
 var enterPlanModeInputSchema = z4.object({
   reason: z4.string().describe("Brief explanation of why you're entering planning mode (e.g., 'Need to explore codebase architecture before implementing feature')")
 });
-var ENTER_PLAN_MODE_DESCRIPTION = `Enter planning mode to explore and design implementation approaches before making changes.
+var ENTER_PLAN_MODE_DESCRIPTION = `Use this tool proactively when you're about to start a non-trivial task. Getting user sign-off on your approach prevents wasted effort and ensures alignment. This tool transitions you into plan mode where you can explore and design an approach for user approval.
 
-**When to use:**
-- Complex tasks requiring research or exploration
-- Need to understand codebase structure before implementing
-- Multiple approaches possible and you need to evaluate trade-offs
-- User explicitly asks you to plan before executing
+## When to Use This Tool
 
-**In planning mode:**
-- Focus on reading, searching, and understanding
-- Avoid making file changes (use Read, Grep, Glob instead of Write, Edit)
-- Document your findings and proposed approach
-- Use ExitPlanMode when ready with a plan for user approval
+**Prefer using EnterPlanMode** for tasks unless they're simple. Use it when ANY of these conditions apply:
 
-**When NOT to use:**
-- Simple, well-defined tasks
-- You already understand the codebase and approach
-- User wants immediate execution`;
+1. **New Functionality**: Adding meaningful new capabilities
+   - Example: "Add a new report" - what format? What data?
+   - Example: "Add validation" - what rules? What error messages?
+
+2. **Multiple Valid Approaches**: The task can be solved in several different ways
+   - Example: "Add caching" - could use Redis, in-memory, file-based, etc.
+   - Example: "Improve performance" - many optimization strategies possible
+
+3. **Modifications**: Changes that affect existing behavior or structure
+   - Example: "Update the workflow" - what exactly should change?
+   - Example: "Refactor this component" - what's the target architecture?
+
+4. **Architectural Decisions**: The task requires choosing between patterns or technologies
+   - Example: "Add real-time updates" - WebSockets vs SSE vs polling
+   - Example: "Implement state management" - different approaches possible
+
+5. **Multi-File Changes**: The task will likely touch more than 2-3 files
+
+6. **Unclear Requirements**: You need to explore before understanding the full scope
+   - Example: "Make this faster" - need to profile and identify bottlenecks
+   - Example: "Fix the bug" - need to investigate root cause
+
+7. **User Preferences Matter**: The approach could reasonably go multiple ways
+   - If you would use AskUser to clarify the approach, use EnterPlanMode instead
+   - Plan mode lets you explore first, then present options with context
+
+## When NOT to Use This Tool
+
+Only skip EnterPlanMode for simple tasks:
+- Single-line or few-line fixes (typos, obvious bugs, small tweaks)
+- Adding a single function with clear requirements
+- Tasks where the user has given very specific, detailed instructions
+- Pure research/exploration tasks
+
+## What Happens in Plan Mode
+
+In plan mode, you'll:
+1. Thoroughly explore using Glob, Grep, and Read tools
+2. Understand existing patterns and architecture
+3. Design an approach
+4. Present your plan to the user for approval
+5. Use AskUser if you need to clarify approaches
+6. Exit plan mode with ExitPlanMode when ready to execute
+
+## Important Notes
+
+- This tool REQUIRES user approval - they must consent to entering plan mode
+- If unsure whether to use it, err on the side of planning - it's better to get alignment upfront than to redo work
+- Users appreciate being consulted before significant changes`;
 function createEnterPlanModeTool(state, onEnter) {
   return tool4({
     description: ENTER_PLAN_MODE_DESCRIPTION,
@@ -602,9 +858,30 @@ import { z as z5 } from "zod";
 var exitPlanModeInputSchema = z5.object({
   plan: z5.string().describe("The plan to present to the user for approval")
 });
-function createExitPlanModeTool(config, onPlanSubmit) {
+var EXIT_PLAN_MODE_DESCRIPTION = `Use this tool when you are in plan mode and have finished planning and are ready for user approval.
+
+## How This Tool Works
+- Pass your completed plan as a parameter
+- This tool signals that you're done planning and ready for the user to review
+- The user will see your plan and can approve or request changes
+
+## When to Use This Tool
+IMPORTANT: Only use this tool when the task requires planning implementation steps. For research tasks where you're gathering information, searching files, or understanding the codebase - do NOT use this tool.
+
+## Handling Ambiguity in Plans
+Before using this tool, ensure your plan is clear and unambiguous. If there are multiple valid approaches or unclear requirements:
+1. Ask the user to clarify (use AskUser tool if available)
+2. Ask about specific implementation choices (e.g., architectural patterns, which library to use)
+3. Clarify any assumptions that could affect the implementation
+4. Only proceed with ExitPlanMode after resolving ambiguities
+
+## Examples
+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(onPlanSubmit) {
   return tool5({
-    description: "Exits planning mode and prompts the user to approve the plan. Use this when you have finished planning and want user confirmation before proceeding.",
+    description: EXIT_PLAN_MODE_DESCRIPTION,
     inputSchema: zodSchema5(exitPlanModeInputSchema),
     execute: async ({
       plan
@@ -634,10 +911,21 @@ var globInputSchema = z6.object({
   pattern: z6.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js", "*.md")'),
   path: z6.string().optional().describe("Directory to search in (defaults to working directory)")
 });
+var GLOB_DESCRIPTION = `
+- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- It is always better to speculatively perform multiple searches in parallel if they are potentially useful
+`;
 function createGlobTool(sandbox, config) {
   return tool6({
-    description: "Search for files matching a glob pattern. Returns file paths sorted by modification time. Use this instead of `find` command.",
+    description: GLOB_DESCRIPTION,
     inputSchema: zodSchema6(globInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       pattern,
       path
@@ -674,36 +962,64 @@ function createGlobTool(sandbox, config) {
 import { tool as tool7, zodSchema as zodSchema7 } from "ai";
 import { z as z7 } from "zod";
 var grepInputSchema = z7.object({
-  pattern: z7.string().describe("The regular expression pattern to search for"),
+  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)"),
-  glob: z7.string().optional().describe('Glob pattern to filter files (e.g. "*.js")'),
+  glob: z7.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
   type: z7.string().optional().describe('File type to search (e.g. "js", "py", "rust")'),
-  output_mode: z7.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content", "files_with_matches", or "count"'),
+  output_mode: z7.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content" shows matching lines, "files_with_matches" shows file paths (default), "count" shows match counts'),
   "-i": z7.boolean().optional().describe("Case insensitive search"),
-  "-n": z7.boolean().optional().describe("Show line numbers (for content mode)"),
-  "-B": z7.number().optional().describe("Lines to show before each match"),
-  "-A": z7.number().optional().describe("Lines to show after each match"),
-  "-C": z7.number().optional().describe("Lines to show before and after each match"),
-  head_limit: z7.number().optional().describe("Limit output to first N lines/entries"),
-  multiline: z7.boolean().optional().describe("Enable multiline mode")
+  "-n": z7.boolean().optional().describe("Show line numbers in output. Requires output_mode: 'content'. Defaults to true."),
+  "-B": z7.number().optional().describe("Number of lines to show before each match. Requires output_mode: 'content'."),
+  "-A": z7.number().optional().describe("Number of lines to show after each match. Requires output_mode: 'content'."),
+  "-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.")
 });
+var GREP_DESCRIPTION = `A powerful content search tool with regex support. Use this instead of running grep commands directly.
+
+**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+")
+- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+
+**Output modes:**
+- "content": Shows matching lines with optional context
+- "files_with_matches": Shows only file paths (default)
+- "count": Shows match counts per file
+
+**Context options (content mode only):**
+- -B: Lines to show before each match
+- -A: Lines to show after each match
+- -C: Lines to show before and after each match
+
+**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).`;
 function createGrepTool(sandbox, config) {
+  const useRipgrep = config?.useRipgrep ?? false;
   return tool7({
-    description: "Powerful search tool built on ripgrep with regex support. Use this instead of the grep command.",
+    description: GREP_DESCRIPTION,
     inputSchema: zodSchema7(grepInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async (input) => {
       const {
         pattern,
         path,
         glob,
         type,
-        output_mode = "content",
+        output_mode = "files_with_matches",
         "-i": caseInsensitive,
         "-n": showLineNumbers = true,
         "-B": beforeContext,
         "-A": afterContext,
         "-C": context,
         head_limit,
+        offset = 0,
         multiline
       } = input;
       const searchPath = path || ".";
@@ -713,32 +1029,52 @@ 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 {
-        const flags = [];
-        if (caseInsensitive)
-          flags.push("-i");
-        if (showLineNumbers && output_mode === "content")
-          flags.push("-n");
-        if (multiline)
-          flags.push("-U");
-        if (context) {
-          flags.push(`-C ${context}`);
-        } else {
-          if (beforeContext)
-            flags.push(`-B ${beforeContext}`);
-          if (afterContext)
-            flags.push(`-A ${afterContext}`);
+        let paginationSuffix = "";
+        if (offset > 0) {
+          paginationSuffix += ` | tail -n +${offset + 1}`;
+        }
+        if (head_limit && head_limit > 0) {
+          paginationSuffix += ` | head -${head_limit}`;
         }
-        if (glob)
-          flags.push(`--include="${glob}"`);
-        if (type)
-          flags.push(`--include="*.${type}"`);
-        const flagStr = flags.join(" ");
-        const limit = head_limit || 1000;
         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 result = await sandbox.exec(cmd, { timeout: config?.timeout });
         if (output_mode === "files_with_matches") {
-          cmd = `grep -rl ${flagStr} "${pattern}" ${searchPath} 2>/dev/null | head -${limit}`;
-          const result = await sandbox.exec(cmd, { timeout: config?.timeout });
           const files = result.stdout.split(`
 `).filter(Boolean);
           return {
@@ -746,8 +1082,6 @@ function createGrepTool(sandbox, config) {
             count: files.length
           };
         } else if (output_mode === "count") {
-          cmd = `grep -rc ${flagStr} "${pattern}" ${searchPath} 2>/dev/null | grep -v ':0$' | head -${limit}`;
-          const result = await sandbox.exec(cmd, { timeout: config?.timeout });
           const lines = result.stdout.split(`
 `).filter(Boolean);
           const counts = lines.map((line) => {
@@ -763,8 +1097,6 @@ function createGrepTool(sandbox, config) {
             total
           };
         } else {
-          cmd = `grep -rn ${flagStr} "${pattern}" ${searchPath} 2>/dev/null | head -${limit}`;
-          const result = await sandbox.exec(cmd, { timeout: config?.timeout });
           if (!result.stdout.trim()) {
             return {
               matches: [],
@@ -798,6 +1130,66 @@ function createGrepTool(sandbox, config) {
     }
   });
 }
+function buildRipgrepCommand(opts) {
+  const flags = [];
+  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 {
+      if (opts.beforeContext)
+        flags.push(`-B ${opts.beforeContext}`);
+      if (opts.afterContext)
+        flags.push(`-A ${opts.afterContext}`);
+    }
+  }
+  if (opts.glob)
+    flags.push(`-g "${opts.glob}"`);
+  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}`;
+  }
+}
+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}`);
+    }
+  }
+  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}`;
+  }
+}
 
 // src/tools/read.ts
 import { tool as tool8, zodSchema as zodSchema8 } from "ai";
@@ -807,10 +1199,25 @@ var readInputSchema = z8.object({
   offset: z8.number().optional().describe("Line number to start reading from (1-indexed)"),
   limit: z8.number().optional().describe("Maximum number of lines to read")
 });
+var READ_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to 500 lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files)
+- Results are returned with line numbers starting at 1
+- This tool can only read text files, not binary files (images, PDFs, etc.)
+- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
+- It is always better to speculatively read multiple potentially useful files in parallel
+- If you read a file that exists but has empty contents you will receive a warning in place of file contents`;
 function createReadTool(sandbox, config) {
   return tool8({
-    description: "Read the contents of a file or list directory entries. For text files, returns numbered lines with total line count. For directories, returns file/folder names. Use this instead of `cat`, `head`, or `tail` commands.",
+    description: READ_DESCRIPTION,
     inputSchema: zodSchema8(readInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       file_path,
       offset,
@@ -967,16 +1374,39 @@ 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
+- Fetches the URL content and extracts text
+- Processes the content with the prompt using the configured model
+- Returns the model's response about the content
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - The prompt should describe what information you want to extract from the page
+  - This tool is read-only and does not modify any files
+  - Results may be summarized if the content is very large
+  - 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: "Fetches content from a URL and processes it with an AI model. Use this to analyze web pages, extract information, or summarize content.",
+    description: WEB_FETCH_DESCRIPTION,
     inputSchema: zodSchema10(webFetchInputSchema),
+    strict,
+    needsApproval,
+    providerOptions,
     execute: async (input) => {
       const { url, prompt } = input;
       try {
@@ -1024,7 +1454,7 @@ ${content}`
           return {
             error: message,
             status_code: statusCode,
-            retryable: RETRYABLE_CODES.includes(statusCode)
+            retryable: RETRYABLE_STATUS_CODES.includes(statusCode)
           };
         }
         return {
@@ -1044,12 +1474,34 @@ 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:**
+- Provides current information for recent events and data
+- Returns results formatted with titles, URLs, and snippets
+- Supports domain filtering to include or block specific websites
+
+**CRITICAL REQUIREMENT - You MUST follow this:**
+After answering using search results, you MUST include a "Sources:" section listing relevant URLs as markdown hyperlinks:
+
+Sources:
+- [Source Title 1](https://example.com/1)
+- [Source Title 2](https://example.com/2)
+
+**Important - Use the correct year:**
+When searching for recent information, documentation, or current events, use the current year in your query (e.g., "React documentation 2025" not "2024").
+
+**Domain filtering:**
+- 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: "Searches the web and returns formatted results. Use this to find current information, documentation, articles, and more.",
+    description: WEB_SEARCH_DESCRIPTION,
     inputSchema: zodSchema11(webSearchInputSchema),
+    strict,
+    needsApproval,
+    providerOptions,
     execute: async (input) => {
       const { query, allowed_domains, blocked_domains } = input;
       try {
@@ -1083,7 +1535,7 @@ function createWebSearchTool(config) {
           return {
             error: message,
             status_code: statusCode,
-            retryable: RETRYABLE_CODES2.includes(statusCode)
+            retryable: RETRYABLE_STATUS_CODES.includes(statusCode)
           };
         }
         return {
@@ -1101,10 +1553,25 @@ var writeInputSchema = z12.object({
   file_path: z12.string().describe("Path to the file to write"),
   content: z12.string().describe("Content to write to the file")
 });
+var WRITE_DESCRIPTION = `Writes content to a file on the filesystem.
+
+**Important guidelines:**
+- This tool will overwrite existing files at the provided path
+- If modifying an existing file, you MUST use the Read tool first to read the file's contents
+- ALWAYS prefer editing existing files over creating new ones
+- NEVER proactively create documentation files (*.md) or README files unless explicitly requested
+- The file_path must be an absolute path, not relative
+
+**When to use Write vs Edit:**
+- Use Write for creating new files or completely replacing file contents
+- Use Edit for making targeted changes to existing files (preferred for modifications)`;
 function createWriteTool(sandbox, config) {
   return tool12({
-    description: "Write content to a file. Creates the file if it does not exist, overwrites if it does.",
+    description: WRITE_DESCRIPTION,
     inputSchema: zodSchema12(writeInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
     execute: async ({
       file_path,
       content
@@ -1148,8 +1615,32 @@ 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.
+
+**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
+- If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead, to find the match more quickly
+- Other tasks that are not related to the available agent types
+
+**Usage notes:**
+- Always include a short description (3-5 words) summarizing what the agent will do
+- Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+- Provide clear, detailed prompts so the agent can work autonomously and return exactly the information you need.
+- The agent's outputs should generally be trusted
+- Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+- If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.`;
 var eventCounter = 0;
 function generateEventId() {
   return `subagent-${Date.now()}-${++eventCounter}`;
@@ -1175,19 +1666,21 @@ function createTaskTool(config) {
     streamWriter
   } = config;
   return tool13({
-    description: "Launches a new agent to handle complex, multi-step tasks autonomously. Use this for tasks that require multiple steps, research, or specialized expertise.",
+    description: TASK_DESCRIPTION,
     inputSchema: zodSchema13(taskInputSchema),
     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,
@@ -1308,9 +1801,41 @@ var todoWriteInputSchema = z14.object({
     activeForm: z14.string().describe("Active form of the task description")
   })).describe("The updated todo list")
 });
-function createTodoWriteTool(state, config, onUpdate) {
+var TODO_WRITE_DESCRIPTION = `Use this tool to create and manage a structured task list for tracking progress. This helps organize complex tasks and gives the user visibility into your work.
+
+**When to use this tool proactively:**
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps
+2. Non-trivial tasks - Tasks requiring careful planning or multiple operations
+3. User explicitly requests a todo list
+4. User provides multiple tasks - Numbered lists or comma-separated items
+5. After receiving new instructions - Immediately capture requirements as todos
+6. When starting work - Mark task as in_progress BEFORE beginning
+7. After completing - Mark as completed and add any follow-up tasks discovered
+
+**When NOT to use:**
+1. Single, straightforward tasks
+2. Trivial tasks with no organizational benefit
+3. Tasks completable in less than 3 trivial steps
+4. Purely conversational or informational requests
+
+**Task states:**
+- pending: Not yet started
+- in_progress: Currently working on (limit to ONE at a time)
+- completed: Finished successfully
+
+**Task format (both required):**
+- content: Imperative form ("Run tests", "Analyze data")
+- activeForm: Present continuous form ("Running tests", "Analyzing data")
+
+**Task management rules:**
+- Update status in real-time as you work
+- Mark complete IMMEDIATELY after finishing (don't batch)
+- 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, onUpdate) {
   return tool14({
-    description: "Creates and manages a structured task list for tracking progress. Use this to plan complex tasks and track completion.",
+    description: TODO_WRITE_DESCRIPTION,
     inputSchema: zodSchema14(todoWriteInputSchema),
     execute: async ({
       todos
@@ -1340,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,
@@ -1375,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
@@ -1728,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) {
@@ -1821,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"];
@@ -1843,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;
@@ -1853,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}`);
@@ -2037,6 +2657,8 @@ export {
   setupAgentEnvironment,
   pruneMessagesByTokens,
   parseSkillMetadata,
+  loadSkillBundles,
+  loadSkillBundle,
   getContextStatus,
   fetchSkills,
   fetchSkill,
@@ -2051,6 +2673,7 @@ export {
   createTodoWriteTool,
   createTaskTool,
   createSkillTool,
+  createRedisCacheStore,
   createReadTool,
   createLocalSandbox,
   createGrepTool,
@@ -2066,7 +2689,10 @@ export {
   contextNeedsCompaction,
   contextNeedsAttention,
   compactConversation,
+  cached,
+  anthropicPromptCacheMiddlewareV2,
   anthropicPromptCacheMiddleware,
   MODEL_CONTEXT_LIMITS,
+  LRUCacheStore,
   DEFAULT_CONFIG
 };