@morphllm/morphsdk 0.2.45 → 0.2.47

package/dist/tools/warp_grep/index.cjs

@@ -30,14 +30,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // tools/warp_grep/index.ts
 var warp_grep_exports = {};
 __export(warp_grep_exports, {
-  AGENT_CONFIG: () => AGENT_CONFIG,
   CommandExecProvider: () => CommandExecProvider,
-  DEFAULT_EXCLUDES: () => DEFAULT_EXCLUDES,
-  DEFAULT_MODEL: () => DEFAULT_MODEL,
   LocalRipgrepProvider: () => LocalRipgrepProvider,
+  WARP_GREP_DESCRIPTION: () => WARP_GREP_DESCRIPTION,
+  WARP_GREP_SYSTEM_PROMPT: () => SYSTEM_PROMPT,
+  WarpGrepClient: () => WarpGrepClient,
   createAnthropicWarpGrepTool: () => createMorphWarpGrepTool2,
   createOpenAIWarpGrepTool: () => createMorphWarpGrepTool,
   createVercelWarpGrepTool: () => createMorphWarpGrepTool3,
+  executeWarpGrep: () => executeWarpGrep,
+  formatResult: () => formatResult,
+  getSystemPrompt: () => getSystemPrompt,
   runWarpGrep: () => runWarpGrep
 });
 module.exports = __toCommonJS(warp_grep_exports);
@@ -48,84 +51,207 @@ var AGENT_CONFIG = {
   MAX_ROUNDS: 10,
   TIMEOUT_MS: 3e4
 };
-var DEFAULT_EXCLUDES = (process.env.MORPH_WARP_GREP_EXCLUDE || "").split(",").map((s) => s.trim()).filter(Boolean).concat(["node_modules", ".git", "dist", "build", ".cache", "venv", "target"]);
+var BUILTIN_EXCLUDES = [
+  // Version control
+  ".git",
+  ".svn",
+  ".hg",
+  ".bzr",
+  // Dependencies
+  "node_modules",
+  "bower_components",
+  ".pnpm",
+  ".yarn",
+  "vendor",
+  "packages",
+  "Pods",
+  ".bundle",
+  // Python
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  ".venv",
+  "venv",
+  ".tox",
+  ".nox",
+  ".eggs",
+  "*.egg-info",
+  // Build outputs
+  "dist",
+  "build",
+  "out",
+  "output",
+  "target",
+  "_build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".vercel",
+  ".netlify",
+  // Cache directories
+  ".cache",
+  ".parcel-cache",
+  ".turbo",
+  ".nx",
+  ".gradle",
+  // IDE/Editor
+  ".idea",
+  ".vscode",
+  ".vs",
+  // Coverage
+  "coverage",
+  ".coverage",
+  "htmlcov",
+  ".nyc_output",
+  // Temporary
+  "tmp",
+  "temp",
+  ".tmp",
+  ".temp",
+  // Lock files
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  // Binary/minified
+  "*.min.js",
+  "*.min.css",
+  "*.bundle.js",
+  "*.wasm",
+  "*.so",
+  "*.dll",
+  "*.pyc",
+  "*.map",
+  "*.js.map",
+  // Hidden directories catch-all
+  ".*"
+];
+var DEFAULT_EXCLUDES = (process.env.MORPH_WARP_GREP_EXCLUDE || "").split(",").map((s) => s.trim()).filter(Boolean).concat(BUILTIN_EXCLUDES);
 var DEFAULT_MODEL = "morph-warp-grep";
 
 // tools/warp_grep/agent/prompt.ts
-var SYSTEM_PROMPT = `You are a code search agent. Your task is to find relevant code snippets based on a search query.
+var SYSTEM_PROMPT = `You are a code search agent. Your task is to find all relevant code for a given query.
 
 <workflow>
-You operate in exactly 3 rounds of tool exploration, followed by a final answer:
+You have exactly 4 turns. The 4th turn MUST be a \`finish\` call. Each turn allows up to 8 parallel tool calls.
 
-1. In each round, you can make MULTIPLE tool calls (up to 8) to search in parallel. All tool results will be returned together after each round.
-2. After your third round of tool calls, your next turn MUST be a single call to the \`finish\` tool with all the context you have found.
-</workflow>
+- Turn 1: Map the territory OR dive deep (based on query specificity)
+- Turn 2-3: Refine based on findings
+- Turn 4: MUST call \`finish\` with all relevant code locations
+- You MAY call \`finish\` early if confident\u2014but never before at least 1 search turn.
 
-<tool_calling>
-You have tools at your disposal to solve the coding task. Follow these rules regarding tool calls:
+Remember, if the task feels easy to you, it is strongly desirable to call \`finish\` early using fewer turns, but quality over speed.
+</workflow>
 
-### 1. \`analyse\` - Explore Directories
-Explore directory structure in a tree-like format.
-**Syntax:** \`analyse <path> [pattern]\`
-- \`<path>\`: Directory path to analyze (defaults to \`.\`)
-- \`[pattern]\`: Optional regex pattern to filter names
+<tools>
+### \`analyse <path> [pattern]\`
+Directory tree or file search. Shows structure of a path, optionally filtered by regex pattern.
+- \`path\`: Required. Directory or file path (use \`.\` for repo root)
+- \`pattern\`: Optional regex to filter results
 
-For example:
+Examples:
 \`\`\`
+analyse .
 analyse src/api
-analyse . "test"
+analyse . ".*\\.ts$"
+analyse src "test.*"
 \`\`\`
 
-### 2. \`read\` - Read File Contents
-Read entire files or specific line ranges.
-**Syntax:** \`read <path>[:start-end]\`
-- \`<path>\`: File path to read
-- \`[:start-end]\`: Optional 1-based, inclusive line range
+### \`read <path>[:start-end]\`
+Read file contents. Line range is 1-based, inclusive.
+- Returns numbered lines for easy reference
+- Omit range to read entire file
 
-For example:
+Examples:
 \`\`\`
 read src/main.py
-read src/database/connection.py:10-50
+read src/db/conn.py:10-50
+read package.json:1-20
 \`\`\`
 
-### 3. \`grep\` - Search with Regex
-Search for regex patterns across files using ripgrep.
-**Syntax:** \`grep '<pattern>' <path>\`
-- \`'<pattern>'\`: Regex pattern (always wrap in single quotes)
-- \`<path>\`: Directory or file to search (use \`.\` for the repo root)
+### \`grep '<pattern>' <path>\`
+Ripgrep search. Finds pattern matches across files.
+- \`'<pattern>'\`: Required. Regex pattern wrapped in single quotes
+- \`<path>\`: Required. Directory or file to search (use \`.\` for repo root)
 
-For example:
+Examples:
 \`\`\`
-grep 'create_user' .
-grep 'import.*requests' src/api
-grep 'class\\\\s+AuthService' controllers/auth.py
+grep 'class.*Service' src/
+grep 'def authenticate' .
+grep 'import.*from' src/components/
+grep 'TODO' .
 \`\`\`
 
-### 4. \`finish\` - Submit Final Answer
-Submit your findings when complete.
-**Syntax:** \`finish <file1:range1,range2...> [file2:range3...]\`
-- Provide file paths with colon-separated, comma-separated line ranges
+### \`finish <file1:ranges> [file2:ranges ...]\`
+Submit final answer with all relevant code locations.
+- Include generous line ranges\u2014don't be stingy with context
+- Ranges are comma-separated: \`file.py:10-30,50-60\`
+- ALWAYS include import statements at the top of files (usually lines 1-20)
+- If code spans multiple files, include ALL of them
+- Small files can be returned in full
 
-For example:
+Examples:
 \`\`\`
-finish src/api/auth.py:25-50,75-80 src/models/user.py:10-15
+finish src/auth.py:1-15,25-50,75-80 src/models/user.py:1-10,20-45
+finish src/index.ts:1-100
 \`\`\`
-</tool_calling>
+</tools>
 
 <strategy>
-- Use the \`analyse\`, \`grep\`, and \`read\` tools to gather information about the codebase.
-- Leverage the tools smartly to make full use of their potential
-- Make parallel tool calls within each round to investigate multiple paths or files efficiently
-- Be systematic and thorough within your 3-round limit
+**Before your first tool call, classify the query:**
+
+| Query Type | Turn 1 Strategy | Early Finish? |
+|------------|-----------------|---------------|
+| **Specific** (function name, error string, unique identifier) | 8 parallel greps on likely paths | Often by turn 2 |
+| **Conceptual** (how does X work, where is Y handled) | analyse + 2-3 broad greps | Rarely early |
+| **Exploratory** (find all tests, list API endpoints) | analyse at multiple depths | Usually needs 3 turns |
+
+**Parallel call patterns:**
+- **Shotgun grep**: Same pattern, 8 different directories\u2014fast coverage
+- **Variant grep**: 8 pattern variations (synonyms, naming conventions)\u2014catches inconsistent codebases
+- **Funnel**: 1 analyse + 7 greps\u2014orient and search simultaneously
+- **Deep read**: 8 reads on files you already identified\u2014gather full context fast
 </strategy>
 
 <output_format>
-- Only output tool calls themselves
-- Do not include explanatory text, reasoning, or commentary
-- Each tool call should be on its own line
-- After 3 rounds of exploration, call \`finish\` with all relevant code snippets you found
+EVERY response MUST follow this exact format:
+
+1. First, wrap your reasoning in \`<think>...</think>\` tags containing:
+   - Query classification (specific/conceptual/exploratory)
+   - Confidence estimate (can I finish in 1-2 turns?)
+   - This turn's parallel strategy
+   - What signals would let me finish early?
+
+2. Then, output tool calls wrapped in \`<tool_call>...</tool_call>\` tags, one per line.
+
+Example:
+\`\`\`
+<think>
+This is a specific query about authentication. I'll grep for auth-related patterns.
+High confidence I can finish in 2 turns if I find the auth module.
+Strategy: Shotgun grep across likely directories.
+</think>
+<tool_call>grep 'authenticate' src/</tool_call>
+<tool_call>grep 'login' src/</tool_call>
+<tool_call>analyse src/auth</tool_call>
+\`\`\`
+
+No commentary outside \`<think>\`. No explanations after tool calls.
 </output_format>
 
+<finishing_requirements>
+When calling \`finish\`:
+- Include the import section (typically lines 1-20) of each file
+- Include all function/class definitions that are relevant
+- Include any type definitions, interfaces, or constants used
+- Better to over-include than leave the user missing context
+- If unsure about boundaries, include more rather than less
+</finishing_requirements>
+
 Begin your exploration now to find code relevant to the query.`;
 function getSystemPrompt() {
   return SYSTEM_PROMPT;
@@ -138,13 +264,54 @@ var LLMResponseParseError = class extends Error {
     this.name = "LLMResponseParseError";
   }
 };
+var VALID_COMMANDS = ["analyse", "grep", "read", "finish"];
+function preprocessText(text) {
+  let processed = text.replace(/<think>[\s\S]*?<\/think>/gi, "");
+  const openingTagRegex = /<tool_call>|<tool>/gi;
+  const closingTagRegex = /<\/tool_call>|<\/tool>/gi;
+  const openingMatches = processed.match(openingTagRegex) || [];
+  const closingMatches = processed.match(closingTagRegex) || [];
+  if (openingMatches.length > closingMatches.length) {
+    const lastClosingMatch = /<\/tool_call>|<\/tool>/gi;
+    let lastClosingIndex = -1;
+    let match;
+    while ((match = lastClosingMatch.exec(processed)) !== null) {
+      lastClosingIndex = match.index + match[0].length;
+    }
+    if (lastClosingIndex > 0) {
+      processed = processed.slice(0, lastClosingIndex);
+    }
+  }
+  const toolCallLines = [];
+  const toolTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>|<tool>([\s\S]*?)<\/tool>/gi;
+  let tagMatch;
+  while ((tagMatch = toolTagRegex.exec(processed)) !== null) {
+    const content = (tagMatch[1] || tagMatch[2] || "").trim();
+    if (content) {
+      const lines = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l);
+      toolCallLines.push(...lines);
+    }
+  }
+  const allLines = processed.split(/\r?\n/).map((l) => l.trim());
+  for (const line of allLines) {
+    if (!line) continue;
+    if (line.startsWith("<")) continue;
+    const firstWord = line.split(/\s/)[0];
+    if (VALID_COMMANDS.includes(firstWord)) {
+      if (!toolCallLines.includes(line)) {
+        toolCallLines.push(line);
+      }
+    }
+  }
+  return toolCallLines;
+}
 var LLMResponseParser = class {
   finishSpecSplitRe = /,(?=[^,\s]+:)/;
   parse(text) {
     if (typeof text !== "string") {
       throw new TypeError("Command text must be a string.");
     }
-    const lines = text.split(/\r?\n/).map((l) => l.trim());
+    const lines = preprocessText(text);
     const commands = [];
     let finishAccumulator = null;
     lines.forEach((line, idx) => {
@@ -167,7 +334,7 @@ var LLMResponseParser = class {
           finishAccumulator = this.handleFinish(parts, ctx, finishAccumulator);
           break;
         default:
-          throw new LLMResponseParseError(`Line ${ctx.lineNumber}: Unsupported command '${cmd}'`);
+          break;
       }
     });
     if (finishAccumulator) {
@@ -709,7 +876,23 @@ async function runWarpGrep(config) {
       }
     }
     if (formatted.length > 0) {
-      messages.push({ role: "user", content: formatted.join("\n") });
+      const turnsUsed = round;
+      const turnsRemaining = 4 - turnsUsed;
+      let turnMessage;
+      if (turnsRemaining === 0) {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] This is your LAST turn. You MUST call the finish tool now.`;
+      } else if (turnsRemaining === 1) {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] You have 1 turn remaining. Next turn you MUST call the finish tool.`;
+      } else {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] You have ${turnsRemaining} turns remaining.`;
+      }
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage });
     }
     if (finishCalls.length) {
       const fc = finishCalls[0];
@@ -752,9 +935,10 @@ var import_path3 = __toESM(require("path"), 1);
 
 // tools/warp_grep/utils/ripgrep.ts
 var import_child_process = require("child_process");
+var import_ripgrep = require("@vscode/ripgrep");
 function runRipgrep(args, opts) {
   return new Promise((resolve) => {
-    const child = (0, import_child_process.spawn)("rg", args, {
+    const child = (0, import_child_process.spawn)(import_ripgrep.rgPath, args, {
       cwd: opts?.cwd,
       env: { ...process.env, ...opts?.env || {} },
       stdio: ["ignore", "pipe", "pipe"]
@@ -937,6 +1121,97 @@ var LocalRipgrepProvider = class {
   }
 };
 
+// tools/warp_grep/core.ts
+var WarpGrepClient = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      apiKey: config.apiKey,
+      debug: config.debug,
+      timeout: config.timeout,
+      retryConfig: config.retryConfig
+    };
+  }
+  /**
+   * Execute a code search query
+   * 
+   * @param input - Search parameters including query, repoRoot, and optional provider
+   * @returns Search results with relevant code contexts
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.execute({
+   *   query: 'Find authentication middleware',
+   *   repoRoot: '.'
+   * });
+   * 
+   * if (result.success) {
+   *   for (const ctx of result.contexts) {
+   *     console.log(`File: ${ctx.file}`);
+   *     console.log(ctx.content);
+   *   }
+   * }
+   * ```
+   */
+  async execute(input) {
+    const provider = input.provider ?? new LocalRipgrepProvider(input.repoRoot, input.excludes);
+    const result = await runWarpGrep({
+      query: input.query,
+      repoRoot: input.repoRoot,
+      provider,
+      excludes: input.excludes,
+      includes: input.includes,
+      debug: input.debug ?? this.config.debug ?? false,
+      apiKey: this.config.apiKey
+    });
+    const finish = result.finish;
+    if (result.terminationReason !== "completed" || !finish?.metadata) {
+      return {
+        success: false,
+        error: "Search did not complete"
+      };
+    }
+    const contexts = (finish.resolved ?? []).map((r) => ({
+      file: r.path,
+      content: r.content
+    }));
+    return {
+      success: true,
+      contexts,
+      summary: finish.payload
+    };
+  }
+};
+async function executeWarpGrep(input, config) {
+  const client = new WarpGrepClient(config);
+  return client.execute(input);
+}
+function formatResult(result) {
+  if (!result.success) {
+    return `Search failed: ${result.error}`;
+  }
+  if (!result.contexts || result.contexts.length === 0) {
+    return "No relevant code found. Try rephrasing your query.";
+  }
+  const lines = [];
+  lines.push(`Found ${result.contexts.length} relevant code sections:
+`);
+  result.contexts.forEach((ctx, i) => {
+    lines.push(`${i + 1}. ${ctx.file}`);
+    lines.push("```");
+    lines.push(ctx.content);
+    lines.push("```");
+    lines.push("");
+  });
+  if (result.summary) {
+    lines.push(`Summary: ${result.summary}`);
+  }
+  return lines.join("\n");
+}
+
+// tools/warp_grep/prompts.ts
+var WARP_GREP_DESCRIPTION = "A fast and accurate tool that can search for all relevant context in a codebase. You must use this tool to save time and avoid context pollution.";
+
 // tools/warp_grep/providers/command.ts
 var CommandExecProvider = class {
   constructor(opts) {
@@ -1003,104 +1278,116 @@ var CommandExecProvider = class {
 };
 
 // tools/warp_grep/openai.ts
-var import_zod = require("zod");
-var INPUT_SCHEMA = import_zod.z.object({
-  query: import_zod.z.string().describe("Free-form repository question")
-});
+var TOOL_PARAMETERS = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Free-form repository question" }
+  },
+  required: ["query"]
+};
+async function execute(input, config) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const result = await runWarpGrep({
+    query: parsed.query,
+    repoRoot: config.repoRoot,
+    provider,
+    excludes: config.excludes,
+    includes: config.includes,
+    debug: config.debug ?? false,
+    apiKey: config.apiKey
+  });
+  const finish = result.finish;
+  if (result.terminationReason !== "completed" || !finish?.metadata) {
+    return { success: false, error: "Search did not complete" };
+  }
+  const contexts = (finish.resolved ?? []).map((r) => ({
+    file: r.path,
+    content: r.content
+  }));
+  return { success: true, contexts, summary: finish.payload };
+}
 function createMorphWarpGrepTool(config) {
   const tool2 = {
     type: "function",
     function: {
       name: "morph-warp-grep",
-      description: config.description ?? "A fast and accurate tool that can search for all relevant context in a codebase. You must use this tool to save time and avoid context pollution.",
-      parameters: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Free-form repository question" }
-        },
-        required: ["query"]
-      }
+      description: config.description ?? WARP_GREP_DESCRIPTION,
+      parameters: TOOL_PARAMETERS
     }
   };
   return Object.assign(tool2, {
     execute: async (input) => {
-      const parsed = INPUT_SCHEMA.parse(typeof input === "string" ? JSON.parse(input) : input);
-      const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
-      const result = await runWarpGrep({
-        query: parsed.query,
-        repoRoot: config.repoRoot,
-        provider,
-        excludes: config.excludes,
-        includes: config.includes,
-        debug: config.debug ?? false,
-        apiKey: config.apiKey
-      });
-      const finish = result.finish;
-      if (result.terminationReason !== "completed" || !finish?.metadata) {
-        return { success: false, error: "Search did not complete", messages: result.messages };
-      }
-      const contexts = (finish.resolved ?? []).map((r) => ({
-        file: r.path,
-        content: r.content
-      }));
-      return { success: true, contexts, summary: finish.payload };
+      return execute(input, config);
+    },
+    formatResult: (result) => {
+      return formatResult(result);
+    },
+    getSystemPrompt: () => {
+      return getSystemPrompt();
     }
   });
 }
 
 // tools/warp_grep/anthropic.ts
-var import_zod2 = require("zod");
-var INPUT_SCHEMA2 = import_zod2.z.object({
-  query: import_zod2.z.string().describe("Free-form repository question")
-});
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Free-form repository question" }
+  },
+  required: ["query"]
+};
+async function execute2(input, config) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const result = await runWarpGrep({
+    query: parsed.query,
+    repoRoot: config.repoRoot,
+    provider,
+    excludes: config.excludes,
+    includes: config.includes,
+    debug: config.debug ?? false,
+    apiKey: config.apiKey
+  });
+  const finish = result.finish;
+  if (result.terminationReason !== "completed" || !finish?.metadata) {
+    return { success: false, error: "Search did not complete" };
+  }
+  const contexts = (finish.resolved ?? []).map((r) => ({
+    file: r.path,
+    content: r.content
+  }));
+  return { success: true, contexts, summary: finish.payload };
+}
 function createMorphWarpGrepTool2(config) {
   const tool2 = {
     name: "morph-warp-grep",
-    description: config.description ?? "A fast and accurate tool that can search for all relevant context in a codebase. You must use this tool to save time and avoid context pollution.",
-    input_schema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Free-form repository question" }
-      },
-      required: ["query"]
-    }
+    description: config.description ?? WARP_GREP_DESCRIPTION,
+    input_schema: INPUT_SCHEMA
   };
   return Object.assign(tool2, {
     execute: async (input) => {
-      const parsed = INPUT_SCHEMA2.parse(typeof input === "string" ? JSON.parse(input) : input);
-      const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
-      const result = await runWarpGrep({
-        query: parsed.query,
-        repoRoot: config.repoRoot,
-        provider,
-        excludes: config.excludes,
-        includes: config.includes,
-        debug: config.debug ?? false,
-        apiKey: config.apiKey
-      });
-      const finish = result.finish;
-      if (result.terminationReason !== "completed" || !finish?.metadata) {
-        return { success: false, error: "Search did not complete", messages: result.messages };
-      }
-      const contexts = (finish.resolved ?? []).map((r) => ({
-        file: r.path,
-        content: r.content
-      }));
-      return { success: true, contexts, summary: finish.payload };
+      return execute2(input, config);
+    },
+    formatResult: (result) => {
+      return formatResult(result);
+    },
+    getSystemPrompt: () => {
+      return getSystemPrompt();
     }
   });
 }
 
 // tools/warp_grep/vercel.ts
 var import_ai = require("ai");
-var import_zod3 = require("zod");
+var import_zod = require("zod");
+var warpGrepSchema = import_zod.z.object({
+  query: import_zod.z.string().describe("Free-form repository question")
+});
 function createMorphWarpGrepTool3(config) {
-  const schema = import_zod3.z.object({
-    query: import_zod3.z.string().describe("Free-form repository question")
-  });
   return (0, import_ai.tool)({
-    description: config.description ?? "A fast and accurate tool that can search for all relevant context in a codebase. You must use this tool to save time and avoid context pollution.",
-    inputSchema: schema,
+    description: config.description ?? WARP_GREP_DESCRIPTION,
+    inputSchema: warpGrepSchema,
     execute: async (params) => {
       const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
       const result = await runWarpGrep({
@@ -1114,7 +1401,7 @@ function createMorphWarpGrepTool3(config) {
       });
       const finish = result.finish;
       if (result.terminationReason !== "completed" || !finish?.metadata) {
-        return { success: false, error: "Search did not complete", messages: result.messages };
+        return { success: false, error: "Search did not complete" };
       }
       const contexts = (finish.resolved ?? []).map((r) => ({
         file: r.path,
@@ -1126,14 +1413,17 @@ function createMorphWarpGrepTool3(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AGENT_CONFIG,
   CommandExecProvider,
-  DEFAULT_EXCLUDES,
-  DEFAULT_MODEL,
   LocalRipgrepProvider,
+  WARP_GREP_DESCRIPTION,
+  WARP_GREP_SYSTEM_PROMPT,
+  WarpGrepClient,
   createAnthropicWarpGrepTool,
   createOpenAIWarpGrepTool,
   createVercelWarpGrepTool,
+  executeWarpGrep,
+  formatResult,
+  getSystemPrompt,
   runWarpGrep
 });
 //# sourceMappingURL=index.cjs.map