@morphllm/morphsdk 0.2.56 → 0.2.58

package/dist/tools/warp_grep/vercel.cjs

@@ -30,7 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // tools/warp_grep/vercel.ts
 var vercel_exports = {};
 __export(vercel_exports, {
-  createMorphWarpGrepTool: () => createMorphWarpGrepTool,
+  createWarpGrepTool: () => createWarpGrepTool,
+  default: () => vercel_default,
   execute: () => execute,
   formatResult: () => formatResult,
   getSystemPrompt: () => getSystemPrompt
@@ -41,9 +42,13 @@ var import_zod = require("zod");
 
 // tools/warp_grep/agent/config.ts
 var AGENT_CONFIG = {
-  // Give the model freedom; failsafe cap to prevent infinite loops
-  MAX_ROUNDS: 10,
-  TIMEOUT_MS: 3e4
+  MAX_TURNS: 4,
+  TIMEOUT_MS: 3e4,
+  MAX_CONTEXT_CHARS: 54e4,
+  MAX_OUTPUT_LINES: 200,
+  MAX_READ_LINES: 800,
+  MAX_LIST_DEPTH: 3,
+  LIST_TIMEOUT_MS: 2e3
 };
 var BUILTIN_EXCLUDES = [
   // Version control
@@ -125,113 +130,191 @@ var BUILTIN_EXCLUDES = [
   ".*"
 ];
 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";
+var DEFAULT_MODEL = "morph-warp-grep-v1";
 
 // tools/warp_grep/agent/prompt.ts
-var SYSTEM_PROMPT = `You are a code search agent. Your task is to find all relevant code for a given query.
+var SYSTEM_PROMPT = `You are a code search agent. Your task is to find all relevant code for a given search_string.
 
-<workflow>
+### workflow
 You have exactly 4 turns. The 4th turn MUST be a \`finish\` call. Each turn allows up to 8 parallel tool calls.
 
-- Turn 1: Map the territory OR dive deep (based on query specificity)
+- Turn 1: Map the territory OR dive deep (based on search_string 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.
+- The user strongly prefers if you can call the finish tool early, but you must be correct
 
-Remember, if the task feels easy to you, it is strongly desirable to call \`finish\` early using fewer turns, but quality over speed.
-</workflow>
+Remember, if the task feels easy to you, it is strongly desirable to call 'finish' early using fewer turns, but quality over speed
 
-<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
+### tools
+Tool calls use nested XML elements:
+\`\`\`xml
+<tool_name>
+  <parameter>value</parameter>
+</tool_name>
+\`\`\`
+
+### \`list_directory\`
+Directory tree view. Shows structure of a path, optionally filtered by regex pattern.
+
+Elements:
+- \`<path>\` (required): Directory path to list (use \`.\` for repo root)
+- \`<pattern>\` (optional): Regex to filter results
 
 Examples:
 \`\`\`
-analyse .
-analyse src/api
-analyse . ".*\\.ts$"
-analyse src "test.*"
+<list_directory>
+  <path>src/services</path>
+</list_directory>
+
+<list_directory>
+  <path>lib/utils</path>
+  <pattern>.*\\.(ts|js)$</pattern>
+</list_directory>
 \`\`\`
 
-### \`read <path>[:start-end]\`
-Read file contents. Line range is 1-based, inclusive.
+### \`read\`
+Read file contents. Supports multiple line ranges.
 - Returns numbered lines for easy reference
-- Omit range to read entire file
+- ALWAYS include import statements (usually lines 1-20). Better to over-include than miss context.
+
+Elements:
+- \`<path>\` (required): File path to read
+- \`<lines>\` (optional): Line ranges like "1-50,75-80,100-120" (omit to read entire file)
 
 Examples:
 \`\`\`
-read src/main.py
-read src/db/conn.py:10-50
-read package.json:1-20
+<read>
+  <path>src/main.py</path>
+</read>
+
+<read>
+  <path>src/auth.py</path>
+  <lines>1-20,45-80,150-200</lines>
+</read>
 \`\`\`
 
-### \`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)
+### \`grep\`
+Search for pattern matches across files. Returns matches with 1 line of context above and below.
+- Match lines use \`:\` separator \u2192 \`filepath:linenum:content\`
+- Context lines use \`-\` separator \u2192 \`filepath-linenum-content\`
+
+Elements:
+- \`<pattern>\` (required): Search pattern (regex). Use \`(a|b)\` for OR patterns.
+- \`<sub_dir>\` (optional): Subdirectory to search in (defaults to \`.\`)
+- \`<glob>\` (optional): File pattern filter like \`*.py\` or \`*.{ts,tsx}\`
 
 Examples:
 \`\`\`
-grep 'class.*Service' src/
-grep 'def authenticate' .
-grep 'import.*from' src/components/
-grep 'TODO' .
+<grep>
+  <pattern>(authenticate|authorize|login)</pattern>
+  <sub_dir>src/auth/</sub_dir>
+</grep>
+
+<grep>
+  <pattern>class.*(Service|Controller)</pattern>
+  <glob>*.{ts,js}</glob>
+</grep>
+
+<grep>
+  <pattern>(DB_HOST|DATABASE_URL|connection)</pattern>
+  <glob>*.{py,yaml,env}</glob>
+  <sub_dir>lib/</sub_dir>
+</grep>
 \`\`\`
 
-### \`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
+### \`finish\`
+Submit final answer with all relevant code locations. Uses nested \`<file>\` elements.
+
+File elements:
+- \`<path>\` (required): File path
+- \`<lines>\` (optional): Line ranges like "1-50,75-80" (\`*\` for entire file)
+
+ALWAYS include import statements (usually lines 1-20). Better to over-include than miss context.
 
 Examples:
 \`\`\`
-finish src/auth.py:1-15,25-50,75-80 src/models/user.py:1-10,20-45
-finish src/index.ts:1-100
+<finish>
+  <file>
+    <path>src/auth.py</path>
+    <lines>1-15,25-50,75-80</lines>
+  </file>
+  <file>
+    <path>src/models/user.py</path>
+    <lines>*</lines>
+  </file>
+</finish>
 \`\`\`
 </tools>
 
 <strategy>
-**Before your first tool call, classify the query:**
+**Before your first tool call, classify the search_string:**
 
-| 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 |
+| Search_string Type | Round 1 Strategy | Early Finish? |
+|------------|------------------|---------------|
+| **Specific** (function name, error string, unique identifier) | 8 parallel greps on likely paths | Often by round 2 |
+| **Conceptual** (how does X work, where is Y handled) | list_directory + 2-3 broad greps | Rarely early |
+| **Exploratory** (find all tests, list API endpoints) | list_directory at multiple depths | Usually needs 3 rounds |
 
 **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
+- **Funnel**: 1 list_directory + 7 greps\u2014orient and search simultaneously
 - **Deep read**: 8 reads on files you already identified\u2014gather full context fast
+
+**Tool call expectations:**
+- Low quality tool calls are ones that give back sparse information. This either means they are not well thought out and are not educated guesses OR, they are too broad and give back too many results.
+- High quality tool calls strike a balance between complexity in the tool call to exclude results we know we don't want, and how wide the search space is so that we don't miss anything. It is ok to start off with wider search spaces, but is imperative that you use your intuition from there on out and seek high quality tool calls only.
+- You are not starting blind, you have some information about root level repo structure going in, so use that to prevent making trivial repo wide queries.
+- The grep tool shows you which file path and line numbers the pattern was found in, use this information smartly when trying to read the file.
 </strategy>
 
 <output_format>
 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
+   - Search_string classification (specific/conceptual/exploratory)
+   - Confidence estimate (can I finish in 1-2 rounds?)
+   - This round'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.
+2. Then, output up to 8 tool calls using nested XML elements.
 
 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.
+This is a specific search_string about authentication. I'll grep for auth-related patterns.
+High confidence I can finish in 2 rounds if I find the auth module. I have already been shown the repo's structure at root
 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>
+<grep>
+  <pattern>(authenticate|login|session)</pattern>
+  <sub_dir>src/auth/</sub_dir>
+</grep>
+<grep>
+  <pattern>(middleware|interceptor)</pattern>
+  <glob>*.{ts,js}</glob>
+</grep>
+<list_directory>
+  <path>src/auth</path>
+</list_directory>
+\`\`\`
+
+Finishing example:
+\`\`\`
+<think>
+I think I have a rough idea, but this is my last turn so I must call the finish tool regardless.
+</think>
+<finish>
+  <file>
+    <path>src/auth/login.py</path>
+    <lines>1-50</lines>
+  </file>
+  <file>
+    <path>src/middleware/session.py</path>
+    <lines>10-80</lines>
+  </file>
+</finish>
 \`\`\`
 
 No commentary outside \`<think>\`. No explanations after tool calls.
@@ -244,17 +327,111 @@ When calling \`finish\`:
 - 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.`;
+</finishing_requirements>`;
 function getSystemPrompt() {
   return SYSTEM_PROMPT;
 }
 
 // tools/warp_grep/agent/parser.ts
-var VALID_COMMANDS = ["analyse", "grep", "read", "finish"];
+var VALID_COMMANDS = ["list_directory", "grep", "read", "finish"];
+function isValidCommand(name) {
+  return VALID_COMMANDS.includes(name);
+}
+function getXmlElementText(xml, tagName) {
+  const regex = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, "i");
+  const match = xml.match(regex);
+  return match ? match[1].trim() : null;
+}
+function parseNestedXmlTools(text) {
+  const tools = [];
+  const toolRegex = /<([a-z_][a-z0-9_]*)>([\s\S]*?)<\/\1>/gi;
+  let match;
+  while ((match = toolRegex.exec(text)) !== null) {
+    const rawToolName = match[1].toLowerCase();
+    const content = match[2];
+    if (!isValidCommand(rawToolName)) continue;
+    const toolName = rawToolName;
+    if (toolName === "list_directory") {
+      const path5 = getXmlElementText(content, "path");
+      const pattern = getXmlElementText(content, "pattern");
+      if (path5) {
+        tools.push({ name: "list_directory", arguments: { path: path5, pattern } });
+      }
+    } else if (toolName === "grep") {
+      const pattern = getXmlElementText(content, "pattern");
+      const subDir = getXmlElementText(content, "sub_dir");
+      const glob = getXmlElementText(content, "glob");
+      if (pattern) {
+        tools.push({
+          name: "grep",
+          arguments: {
+            pattern,
+            path: subDir || ".",
+            ...glob && { glob }
+          }
+        });
+      }
+    } else if (toolName === "read") {
+      const path5 = getXmlElementText(content, "path");
+      const linesStr = getXmlElementText(content, "lines");
+      if (path5) {
+        const args = { path: path5 };
+        if (linesStr) {
+          const ranges = [];
+          for (const rangeStr of linesStr.split(",")) {
+            const trimmed = rangeStr.trim();
+            if (!trimmed) continue;
+            const [s, e] = trimmed.split("-").map((v) => parseInt(v.trim(), 10));
+            if (Number.isFinite(s) && Number.isFinite(e)) {
+              ranges.push([s, e]);
+            } else if (Number.isFinite(s)) {
+              ranges.push([s, s]);
+            }
+          }
+          if (ranges.length === 1) {
+            args.start = ranges[0][0];
+            args.end = ranges[0][1];
+          } else if (ranges.length > 1) {
+            args.lines = ranges;
+          }
+        }
+        tools.push({ name: "read", arguments: args });
+      }
+    } else if (toolName === "finish") {
+      const fileRegex = /<file>([\s\S]*?)<\/file>/gi;
+      const files = [];
+      let fileMatch;
+      while ((fileMatch = fileRegex.exec(content)) !== null) {
+        const fileContent = fileMatch[1];
+        const filePath = getXmlElementText(fileContent, "path");
+        const linesStr = getXmlElementText(fileContent, "lines");
+        if (filePath && linesStr) {
+          const ranges = [];
+          for (const rangeStr of linesStr.split(",")) {
+            if (rangeStr.trim() === "*") {
+              ranges.push([1, 999999]);
+            } else {
+              const [s, e] = rangeStr.split("-").map((v) => parseInt(v.trim(), 10));
+              if (Number.isFinite(s) && Number.isFinite(e)) {
+                ranges.push([s, e]);
+              }
+            }
+          }
+          if (ranges.length > 0) {
+            files.push({ path: filePath, lines: ranges });
+          }
+        }
+      }
+      if (files.length > 0) {
+        tools.push({ name: "finish", arguments: { files } });
+      }
+    }
+  }
+  return tools;
+}
 function preprocessText(text) {
   let processed = text.replace(/<think>[\s\S]*?<\/think>/gi, "");
+  const nestedTools = parseNestedXmlTools(processed);
   const openingTagRegex = /<tool_call>|<tool>/gi;
   const closingTagRegex = /<\/tool_call>|<\/tool>/gi;
   const openingMatches = processed.match(openingTagRegex) || [];
@@ -291,7 +468,7 @@ function preprocessText(text) {
       }
     }
   }
-  return toolCallLines;
+  return { lines: toolCallLines, nestedTools };
 }
 var LLMResponseParser = class {
   finishSpecSplitRe = /,(?=[^,\s]+:)/;
@@ -299,8 +476,8 @@ var LLMResponseParser = class {
     if (typeof text !== "string") {
       throw new TypeError("Command text must be a string.");
     }
-    const lines = preprocessText(text);
-    const commands = [];
+    const { lines, nestedTools } = preprocessText(text);
+    const commands = [...nestedTools];
     let finishAccumulator = null;
     lines.forEach((line) => {
       if (!line || line.startsWith("#")) return;
@@ -308,8 +485,8 @@ var LLMResponseParser = class {
       if (parts.length === 0) return;
       const cmd = parts[0];
       switch (cmd) {
-        case "analyse":
-          this.handleAnalyse(parts, line, commands);
+        case "list_directory":
+          this.handleListDirectory(parts, line, commands);
           break;
         case "grep":
           this.handleGrep(parts, line, commands);
@@ -327,8 +504,8 @@ var LLMResponseParser = class {
     if (finishAccumulator) {
       const map = finishAccumulator;
       const entries = [...map.entries()];
-      const filesPayload = entries.map(([path4, ranges]) => ({
-        path: path4,
+      const filesPayload = entries.map(([path5, ranges]) => ({
+        path: path5,
         lines: [...ranges].sort((a, b) => a[0] - b[0])
       }));
       commands.push({ name: "finish", arguments: { files: filesPayload } });
@@ -360,18 +537,17 @@ var LLMResponseParser = class {
   skip(message) {
     return { name: "_skip", arguments: { message } };
   }
-  handleAnalyse(parts, rawLine, commands) {
+  handleListDirectory(parts, rawLine, commands) {
     if (parts.length < 2) {
       commands.push(this.skip(
-        `[SKIPPED] Your command "${rawLine}" is missing a path. Correct format: analyse <path> [pattern]. Example: analyse src/`
+        `[SKIPPED] Your command "${rawLine}" is missing a path. Correct format: list_directory <path> [pattern]. Example: list_directory src/`
       ));
       return;
     }
-    const path4 = parts[1];
+    const path5 = parts[1];
     const pattern = parts[2]?.replace(/^"|"$/g, "") ?? null;
-    commands.push({ name: "analyse", arguments: { path: path4, pattern } });
+    commands.push({ name: "list_directory", arguments: { path: path5, pattern } });
   }
-  // no glob tool in MCP
   handleGrep(parts, rawLine, commands) {
     if (parts.length < 3) {
       commands.push(this.skip(
@@ -442,8 +618,30 @@ var LLMResponseParser = class {
   }
 };
 
-// tools/warp_grep/tools/read.ts
+// tools/warp_grep/agent/tools/grep.ts
+async function toolGrep(provider, args) {
+  const res = await provider.grep(args);
+  if (res.error) {
+    return { output: res.error };
+  }
+  if (!res.lines.length) {
+    return { output: "no matches" };
+  }
+  return { output: res.lines.join("\n") };
+}
+
+// tools/warp_grep/agent/tools/read.ts
 async function toolRead(provider, args) {
+  if (args.lines && args.lines.length > 0) {
+    const chunks = [];
+    for (const [start, end] of args.lines) {
+      const res2 = await provider.read({ path: args.path, start, end });
+      if (res2.error) return res2.error;
+      chunks.push(res2.lines.join("\n"));
+    }
+    if (chunks.every((c) => c === "")) return "(empty file)";
+    return chunks.join("\n...\n");
+  }
   const res = await provider.read({ path: args.path, start: args.start, end: args.end });
   if (res.error) {
     return res.error;
@@ -452,16 +650,56 @@ async function toolRead(provider, args) {
   return res.lines.join("\n");
 }
 
-// tools/warp_grep/tools/analyse.ts
-async function toolAnalyse(provider, args) {
-  const list = await provider.analyse({
+// tools/warp_grep/agent/tools/list_directory.ts
+async function toolListDirectory(provider, args) {
+  const list = await provider.listDirectory({
     path: args.path,
     pattern: args.pattern ?? null,
-    maxResults: args.maxResults ?? 100,
-    maxDepth: args.maxDepth ?? 2
+    maxResults: args.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES,
+    maxDepth: args.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH
   });
   if (!list.length) return "empty";
-  return list.map((e) => `${"  ".repeat(e.depth)}- ${e.type === "dir" ? "[D]" : "[F]"} ${e.name}`).join("\n");
+  if (list.length >= AGENT_CONFIG.MAX_OUTPUT_LINES) {
+    return "query not specific enough, tool called tried to return too much context and failed";
+  }
+  return list.map((e) => {
+    const indent = "  ".repeat(e.depth);
+    const name = e.type === "dir" ? `${e.name}/` : e.name;
+    return `${indent}${name}`;
+  }).join("\n");
+}
+
+// tools/warp_grep/agent/tools/finish.ts
+async function readFinishFiles(repoRoot, files, reader) {
+  const out = [];
+  for (const f of files) {
+    const ranges = mergeRanges(f.lines);
+    const chunks = [];
+    for (const [s, e] of ranges) {
+      const lines = await reader(f.path, s, e);
+      chunks.push(lines.join("\n"));
+    }
+    out.push({ path: f.path, ranges, content: chunks.join("\n") });
+  }
+  return out;
+}
+function mergeRanges(ranges) {
+  if (!ranges.length) return [];
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  let [cs, ce] = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    const [s, e] = sorted[i];
+    if (s <= ce + 1) {
+      ce = Math.max(ce, e);
+    } else {
+      merged.push([cs, ce]);
+      cs = s;
+      ce = e;
+    }
+  }
+  merged.push([cs, ce]);
+  return merged;
 }
 
 // tools/utils/resilience.ts
@@ -554,8 +792,8 @@ var ToolOutputFormatter = class {
     switch (name) {
       case "read":
         return this.formatRead(safeArgs, payload, isError);
-      case "analyse":
-        return this.formatAnalyse(safeArgs, payload, isError);
+      case "list_directory":
+        return this.formatListDirectory(safeArgs, payload, isError);
       case "grep":
         return this.formatGrep(safeArgs, payload, isError);
       default:
@@ -568,39 +806,56 @@ ${payload}
     if (isError) {
       return payload;
     }
-    const path4 = this.asString(args.path) || "...";
-    return `<file path="${path4}">
+    const path5 = this.asString(args.path) || "...";
+    const start = args.start;
+    const end = args.end;
+    const linesArray = args.lines;
+    const attributes = [`path="${path5}"`];
+    if (linesArray && linesArray.length > 0) {
+      const rangeStr = linesArray.map(([s, e]) => `${s}-${e}`).join(",");
+      attributes.push(`lines="${rangeStr}"`);
+    } else if (start !== void 0 && end !== void 0) {
+      attributes.push(`lines="${start}-${end}"`);
+    }
+    return `<read ${attributes.join(" ")}>
 ${payload}
-</file>`;
+</read>`;
   }
-  formatAnalyse(args, payload, isError) {
-    const path4 = this.asString(args.path) || ".";
+  formatListDirectory(args, payload, isError) {
+    const path5 = this.asString(args.path) || ".";
+    const pattern = this.asString(args.pattern);
+    const attributes = [`path="${path5}"`];
+    if (pattern) {
+      attributes.push(`pattern="${pattern}"`);
+    }
     if (isError) {
-      return `<analyse_results path="${path4}" status="error">
-${payload}
-</analyse_results>`;
+      attributes.push('status="error"');
     }
-    return `<analyse_results path="${path4}">
+    return `<list_directory ${attributes.join(" ")}>
 ${payload}
-</analyse_results>`;
+</list_directory>`;
   }
   formatGrep(args, payload, isError) {
     const pattern = this.asString(args.pattern);
-    const path4 = this.asString(args.path);
+    const subDir = this.asString(args.path);
+    const glob = this.asString(args.glob);
     const attributes = [];
     if (pattern !== void 0) {
       attributes.push(`pattern="${pattern}"`);
     }
-    if (path4 !== void 0) {
-      attributes.push(`path="${path4}"`);
+    if (subDir !== void 0) {
+      attributes.push(`sub_dir="${subDir}"`);
+    }
+    if (glob !== void 0) {
+      attributes.push(`glob="${glob}"`);
     }
     if (isError) {
       attributes.push('status="error"');
     }
     const attrText = attributes.length ? ` ${attributes.join(" ")}` : "";
-    return `<grep_output${attrText}>
+    return `<grep${attrText}>
 ${payload}
-</grep_output>`;
+</grep>`;
   }
   asString(value) {
     if (value === null || value === void 0) {
@@ -614,180 +869,100 @@ function formatAgentToolOutput(toolName, args, output, options = {}) {
   return sharedFormatter.format(toolName, args, output, options);
 }
 
-// tools/warp_grep/agent/grep_helpers.ts
-var GrepState = class {
-  seenLines = /* @__PURE__ */ new Set();
-  isNew(path4, lineNumber) {
-    const key = this.makeKey(path4, lineNumber);
-    return !this.seenLines.has(key);
-  }
-  add(path4, lineNumber) {
-    this.seenLines.add(this.makeKey(path4, lineNumber));
-  }
-  makeKey(path4, lineNumber) {
-    return `${path4}:${lineNumber}`;
-  }
-};
-var MAX_GREP_OUTPUT_CHARS_PER_TURN = 6e4;
-function extractMatchFields(payload) {
-  const text = payload.replace(/\r?\n$/, "");
-  if (!text || text.startsWith("[error]")) {
-    return null;
-  }
-  const firstSep = text.indexOf(":");
-  if (firstSep === -1) {
-    return null;
-  }
-  let filePath = text.slice(0, firstSep).trim();
-  if (!filePath) {
-    return null;
-  }
-  if (filePath.startsWith("./") || filePath.startsWith(".\\")) {
-    filePath = filePath.slice(2);
-  }
-  const remainder = text.slice(firstSep + 1);
-  const secondSep = remainder.indexOf(":");
-  if (secondSep === -1) {
-    return null;
-  }
-  const linePart = remainder.slice(0, secondSep);
-  const lineNumber = Number.parseInt(linePart, 10);
-  if (!Number.isInteger(lineNumber) || lineNumber <= 0) {
-    return null;
-  }
-  let contentSegment = remainder.slice(secondSep + 1);
-  const columnSep = contentSegment.indexOf(":");
-  if (columnSep !== -1 && /^\d+$/.test(contentSegment.slice(0, columnSep))) {
-    contentSegment = contentSegment.slice(columnSep + 1);
-  }
-  const content = contentSegment.trim();
-  if (!content) {
-    return null;
+// tools/warp_grep/agent/helpers.ts
+var import_path = __toESM(require("path"), 1);
+var TRUNCATED_MARKER = "[truncated for context limit]";
+function formatTurnMessage(turnsUsed, maxTurns) {
+  const turnsRemaining = maxTurns - turnsUsed;
+  if (turnsRemaining === 1) {
+    return `
+You have used ${turnsUsed} turns, you only have 1 turn remaining. You have run out of turns to explore the code base and MUST call the finish tool now`;
   }
-  return { path: filePath, lineNumber, content };
+  return `
+You have used ${turnsUsed} turn${turnsUsed === 1 ? "" : "s"} and have ${turnsRemaining} remaining`;
 }
-function parseAndFilterGrepOutput(rawOutput, state) {
-  const matches = [];
-  if (typeof rawOutput !== "string" || !rawOutput.trim()) {
-    return matches;
-  }
-  for (const line of rawOutput.split(/\r?\n/)) {
-    const fields = extractMatchFields(line);
-    if (!fields) {
-      continue;
-    }
-    if (state.isNew(fields.path, fields.lineNumber)) {
-      matches.push(fields);
-      state.add(fields.path, fields.lineNumber);
-    }
-  }
-  return matches;
+function calculateContextBudget(messages) {
+  const totalChars = messages.reduce((sum, m) => sum + m.content.length, 0);
+  const maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS;
+  const percent = Math.round(totalChars / maxChars * 100);
+  const usedK = Math.round(totalChars / 1e3);
+  const maxK = Math.round(maxChars / 1e3);
+  return `<context_budget>${percent}% (${usedK}K/${maxK}K chars)</context_budget>`;
 }
-function truncateOutput(payload, maxChars) {
-  if (payload.length <= maxChars) {
-    return payload;
-  }
-  const note = "... (output truncated)";
-  const available = maxChars - note.length - 1;
-  if (available <= 0) {
-    return note;
-  }
-  if (payload.length <= available) {
-    return `${payload.slice(0, available).replace(/\n$/, "")}
-${note}`;
+async function buildInitialState(repoRoot, query, provider) {
+  try {
+    const entries = await provider.listDirectory({
+      path: ".",
+      maxResults: AGENT_CONFIG.MAX_OUTPUT_LINES,
+      maxDepth: 2
+    });
+    const treeLines = entries.map((e) => {
+      const indent = "  ".repeat(e.depth);
+      const name = e.type === "dir" ? `${e.name}/` : e.name;
+      return `${indent}${name}`;
+    });
+    const repoName = import_path.default.basename(repoRoot);
+    const treeOutput = treeLines.length > 0 ? `${repoName}/
+${treeLines.join("\n")}` : `${repoName}/`;
+    return `<repo_structure>
+${treeOutput}
+</repo_structure>
+
+<search_string>
+${query}
+</search_string>`;
+  } catch {
+    const repoName = import_path.default.basename(repoRoot);
+    return `<repo_structure>
+${repoName}/
+</repo_structure>
+
+<search_string>
+${query}
+</search_string>`;
   }
-  const core = payload.slice(0, Math.max(0, available - 1));
-  const trimmed = core.replace(/\n$/, "").replace(/\s+$/, "");
-  const snippet = trimmed ? `${trimmed}\u2026` : "\u2026";
-  return `${snippet}
-${note}`;
 }
-function formatTurnGrepOutput(matches, maxChars = MAX_GREP_OUTPUT_CHARS_PER_TURN) {
-  if (!matches || matches.length === 0) {
-    return "No new matches found.";
+function enforceContextLimit(messages, maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS) {
+  const getTotalChars = () => messages.reduce((sum, m) => sum + m.content.length, 0);
+  if (getTotalChars() <= maxChars) {
+    return messages;
   }
-  const matchesByFile = /* @__PURE__ */ new Map();
-  for (const match of matches) {
-    if (!matchesByFile.has(match.path)) {
-      matchesByFile.set(match.path, []);
+  const userIndices = [];
+  let firstUserSkipped = false;
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "user") {
+      if (!firstUserSkipped) {
+        firstUserSkipped = true;
+        continue;
+      }
+      userIndices.push(i);
     }
-    matchesByFile.get(match.path).push(match);
   }
-  const lines = [];
-  const sortedPaths = Array.from(matchesByFile.keys()).sort();
-  sortedPaths.forEach((filePath, index) => {
-    if (index > 0) {
-      lines.push("");
-    }
-    lines.push(filePath);
-    const sortedMatches = matchesByFile.get(filePath).slice().sort((a, b) => a.lineNumber - b.lineNumber);
-    for (const match of sortedMatches) {
-      lines.push(`${match.lineNumber}:${match.content}`);
-    }
-  });
-  return truncateOutput(lines.join("\n"), maxChars);
-}
-
-// tools/warp_grep/tools/finish.ts
-async function readFinishFiles(repoRoot, files, reader) {
-  const out = [];
-  for (const f of files) {
-    const ranges = mergeRanges(f.lines);
-    const chunks = [];
-    for (const [s, e] of ranges) {
-      const lines = await reader(f.path, s, e);
-      chunks.push(lines.join("\n"));
+  for (const idx of userIndices) {
+    if (getTotalChars() <= maxChars) {
+      break;
     }
-    out.push({ path: f.path, ranges, content: chunks.join("\n") });
-  }
-  return out;
-}
-function mergeRanges(ranges) {
-  if (!ranges.length) return [];
-  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
-  const merged = [];
-  let [cs, ce] = sorted[0];
-  for (let i = 1; i < sorted.length; i++) {
-    const [s, e] = sorted[i];
-    if (s <= ce + 1) {
-      ce = Math.max(ce, e);
-    } else {
-      merged.push([cs, ce]);
-      cs = s;
-      ce = e;
+    if (messages[idx].content !== TRUNCATED_MARKER) {
+      messages[idx] = { role: "user", content: TRUNCATED_MARKER };
     }
   }
-  merged.push([cs, ce]);
-  return merged;
+  return messages;
 }
 
 // tools/warp_grep/agent/runner.ts
-var import_path = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 var parser = new LLMResponseParser();
-async function buildInitialState(repoRoot, query, provider) {
-  try {
-    const entries = await provider.analyse({ path: ".", maxResults: 100 });
-    const dirs = entries.filter((e) => e.type === "dir").map((d) => d.name).slice(0, 50);
-    const files = entries.filter((e) => e.type === "file").map((f) => f.name).slice(0, 50);
-    const parts = [
-      `<repo_root>${repoRoot}</repo_root>`,
-      `<top_dirs>${dirs.join(", ")}</top_dirs>`,
-      `<top_files>${files.join(", ")}</top_files>`
-    ];
-    return parts.join("\n");
-  } catch {
-    return `<repo_root>${repoRoot}</repo_root>`;
-  }
-}
-async function callModel(messages, model, apiKey) {
-  const api = "https://api.morphllm.com/v1/chat/completions";
+var DEFAULT_API_URL = "https://api.morphllm.com";
+async function callModel(messages, model, options = {}) {
+  const baseUrl = DEFAULT_API_URL;
+  const apiKey = options.morphApiKey || process.env.MORPH_API_KEY || "";
   const fetchPromise = fetchWithRetry(
-    api,
+    `${baseUrl}/v1/chat/completions`,
     {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey || process.env.MORPH_API_KEY || ""}`
+        Authorization: `Bearer ${apiKey}`
       },
       body: JSON.stringify({
         model,
@@ -796,10 +971,15 @@ async function callModel(messages, model, apiKey) {
         messages
       })
     },
-    {}
+    options.retryConfig
   );
   const resp = await withTimeout(fetchPromise, AGENT_CONFIG.TIMEOUT_MS, "morph-warp-grep request timed out");
   if (!resp.ok) {
+    if (resp.status === 404) {
+      throw new Error(
+        "The endpoint you are trying to call is likely deprecated. Please update with: npm cache clean --force && npx -y @morphllm/morphmcp@latest or visit: https://morphllm.com/mcp"
+      );
+    }
     const t = await resp.text();
     throw new Error(`morph-warp-grep error ${resp.status}: ${t}`);
   }
@@ -811,23 +991,24 @@ async function callModel(messages, model, apiKey) {
   return content;
 }
 async function runWarpGrep(config) {
-  const repoRoot = import_path.default.resolve(config.repoRoot || process.cwd());
+  const repoRoot = import_path2.default.resolve(config.repoRoot || process.cwd());
   const messages = [];
-  const systemMessage = { role: "system", content: getSystemPrompt() };
-  messages.push(systemMessage);
-  const queryContent = `<query>${config.query}</query>`;
-  messages.push({ role: "user", content: queryContent });
+  messages.push({ role: "system", content: getSystemPrompt() });
   const initialState = await buildInitialState(repoRoot, config.query, config.provider);
   messages.push({ role: "user", content: initialState });
-  const maxRounds = AGENT_CONFIG.MAX_ROUNDS;
+  const maxTurns = AGENT_CONFIG.MAX_TURNS;
   const model = config.model || DEFAULT_MODEL;
   const provider = config.provider;
   const errors = [];
-  const grepState = new GrepState();
   let finishMeta;
   let terminationReason = "terminated";
-  for (let round = 1; round <= maxRounds; round += 1) {
-    const assistantContent = await callModel(messages, model, config.apiKey).catch((e) => {
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    enforceContextLimit(messages);
+    const assistantContent = await callModel(messages, model, {
+      morphApiKey: config.morphApiKey,
+      morphApiUrl: config.morphApiUrl,
+      retryConfig: config.retryConfig
+    }).catch((e) => {
       errors.push({ message: e instanceof Error ? e.message : String(e) });
       return "";
     });
@@ -835,13 +1016,13 @@ async function runWarpGrep(config) {
     messages.push({ role: "assistant", content: assistantContent });
     const toolCalls = parser.parse(assistantContent);
     if (toolCalls.length === 0) {
-      errors.push({ message: "No tool calls produced by the model." });
+      errors.push({ message: "No tool calls produced by the model. Your MCP is likely out of date! Update it by running: npm cache clean --force && npx -y @morphllm/morphmcp@latest" });
       terminationReason = "terminated";
       break;
     }
     const finishCalls = toolCalls.filter((c) => c.name === "finish");
     const grepCalls = toolCalls.filter((c) => c.name === "grep");
-    const analyseCalls = toolCalls.filter((c) => c.name === "analyse");
+    const listDirCalls = toolCalls.filter((c) => c.name === "list_directory");
     const readCalls = toolCalls.filter((c) => c.name === "read");
     const skipCalls = toolCalls.filter((c) => c.name === "_skip");
     const formatted = [];
@@ -849,69 +1030,42 @@ async function runWarpGrep(config) {
       const msg = c.arguments?.message || "Command skipped due to parsing error";
       formatted.push(msg);
     }
-    const otherPromises = [];
-    for (const c of analyseCalls) {
+    const allPromises = [];
+    for (const c of grepCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolGrep(provider, args).then(
+          ({ output }) => formatAgentToolOutput("grep", args, output, { isError: false }),
+          (err) => formatAgentToolOutput("grep", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of listDirCalls) {
       const args = c.arguments ?? {};
-      otherPromises.push(
-        toolAnalyse(provider, args).then(
-          (p) => formatAgentToolOutput("analyse", args, p, { isError: false }),
-          (err) => formatAgentToolOutput("analyse", args, String(err), { isError: true })
+      allPromises.push(
+        toolListDirectory(provider, args).then(
+          (p) => formatAgentToolOutput("list_directory", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("list_directory", args, String(err), { isError: true })
         )
       );
     }
     for (const c of readCalls) {
       const args = c.arguments ?? {};
-      otherPromises.push(
+      allPromises.push(
         toolRead(provider, args).then(
           (p) => formatAgentToolOutput("read", args, p, { isError: false }),
           (err) => formatAgentToolOutput("read", args, String(err), { isError: true })
         )
       );
     }
-    const otherResults = await Promise.all(otherPromises);
-    formatted.push(...otherResults);
-    for (const c of grepCalls) {
-      const args = c.arguments ?? {};
-      try {
-        const grepRes = await provider.grep({ pattern: args.pattern, path: args.path });
-        if (grepRes.error) {
-          errors.push({ message: grepRes.error });
-          terminationReason = "terminated";
-          return {
-            terminationReason: "terminated",
-            messages,
-            errors
-          };
-        }
-        const rawOutput = Array.isArray(grepRes.lines) ? grepRes.lines.join("\n") : "";
-        const newMatches = parseAndFilterGrepOutput(rawOutput, grepState);
-        let formattedPayload = formatTurnGrepOutput(newMatches);
-        if (formattedPayload === "No new matches found.") {
-          formattedPayload = "no new matches";
-        }
-        formatted.push(formatAgentToolOutput("grep", args, formattedPayload, { isError: false }));
-      } catch (err) {
-        formatted.push(formatAgentToolOutput("grep", args, String(err), { isError: true }));
-      }
+    const allResults = await Promise.all(allPromises);
+    for (const result of allResults) {
+      formatted.push(result);
     }
     if (formatted.length > 0) {
-      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 });
+      const turnMessage = formatTurnMessage(turn, maxTurns);
+      const contextBudget = calculateContextBudget(messages);
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
     }
     if (finishCalls.length) {
       const fc = finishCalls[0];
@@ -961,7 +1115,7 @@ async function runWarpGrep(config) {
 
 // tools/warp_grep/providers/local.ts
 var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_path3 = __toESM(require("path"), 1);
+var import_path4 = __toESM(require("path"), 1);
 
 // tools/warp_grep/utils/ripgrep.ts
 var import_child_process = require("child_process");
@@ -1026,21 +1180,21 @@ async function runRipgrep(args, opts) {
 
 // tools/warp_grep/utils/paths.ts
 var import_fs = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
+var import_path3 = __toESM(require("path"), 1);
 function resolveUnderRepo(repoRoot, targetPath) {
-  const absRoot = import_path2.default.resolve(repoRoot);
-  const resolved = import_path2.default.resolve(absRoot, targetPath);
+  const absRoot = import_path3.default.resolve(repoRoot);
+  const resolved = import_path3.default.resolve(absRoot, targetPath);
   ensureWithinRepo(absRoot, resolved);
   return resolved;
 }
 function ensureWithinRepo(repoRoot, absTarget) {
-  const rel = import_path2.default.relative(import_path2.default.resolve(repoRoot), import_path2.default.resolve(absTarget));
-  if (rel.startsWith("..") || import_path2.default.isAbsolute(rel)) {
+  const rel = import_path3.default.relative(import_path3.default.resolve(repoRoot), import_path3.default.resolve(absTarget));
+  if (rel.startsWith("..") || import_path3.default.isAbsolute(rel)) {
     throw new Error(`Path outside repository root: ${absTarget}`);
   }
 }
 function toRepoRelative(repoRoot, absPath) {
-  return import_path2.default.relative(import_path2.default.resolve(repoRoot), import_path2.default.resolve(absPath));
+  return import_path3.default.relative(import_path3.default.resolve(repoRoot), import_path3.default.resolve(absPath));
 }
 function isSymlink(p) {
   try {
@@ -1083,10 +1237,18 @@ var LocalRipgrepProvider = class {
     this.excludes = excludes;
   }
   async grep(params) {
-    const abs = resolveUnderRepo(this.repoRoot, params.path);
+    let abs;
+    try {
+      abs = resolveUnderRepo(this.repoRoot, params.path);
+    } catch (err) {
+      return {
+        lines: [],
+        error: `[PATH ERROR] ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
     const stat = await import_promises2.default.stat(abs).catch(() => null);
     if (!stat) return { lines: [] };
-    const targetArg = abs === import_path3.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
+    const targetArg = abs === import_path4.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
     const args = [
       "--no-config",
       "--no-heading",
@@ -1095,6 +1257,9 @@ var LocalRipgrepProvider = class {
       "--color=never",
       "--trim",
       "--max-columns=400",
+      "-C",
+      "1",
+      ...params.glob ? ["--glob", params.glob] : [],
       ...this.excludes.flatMap((e) => ["-g", `!${e}`]),
       params.pattern,
       targetArg || "."
@@ -1119,29 +1284,24 @@ Details: ${res.stderr}` : ""}`
       };
     }
     const lines = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
-    return { lines };
-  }
-  async glob(params) {
-    const abs = resolveUnderRepo(this.repoRoot, params.path);
-    const targetArg = abs === import_path3.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
-    const args = [
-      "--no-config",
-      "--files",
-      "-g",
-      params.pattern,
-      ...this.excludes.flatMap((e) => ["-g", `!${e}`]),
-      targetArg || "."
-    ];
-    const res = await runRipgrep(args, { cwd: this.repoRoot });
-    if (res.exitCode === -1) {
-      console.warn(`[warp_grep] ripgrep not available for glob: ${res.stderr || "execution failed"}`);
-      return { files: [] };
+    if (lines.length > AGENT_CONFIG.MAX_OUTPUT_LINES) {
+      return {
+        lines: [],
+        error: "query not specific enough, tool tried to return too much context and failed"
+      };
     }
-    const files = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
-    return { files };
+    return { lines };
   }
   async read(params) {
-    const abs = resolveUnderRepo(this.repoRoot, params.path);
+    let abs;
+    try {
+      abs = resolveUnderRepo(this.repoRoot, params.path);
+    } catch (err) {
+      return {
+        lines: [],
+        error: `[PATH ERROR] ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
     const stat = await import_promises2.default.stat(abs).catch(() => null);
     if (!stat || !stat.isFile()) {
       return {
@@ -1161,7 +1321,15 @@ Details: ${res.stderr}` : ""}`
         error: `[UNREADABLE FILE] You tried to read "${params.path}" but this file is either too large or not a text file, so it cannot be read. Try a different file.`
       };
     }
-    const lines = await readAllLines(abs);
+    let lines;
+    try {
+      lines = await readAllLines(abs);
+    } catch (err) {
+      return {
+        lines: [],
+        error: `[READ ERROR] Failed to read "${params.path}": ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
     const total = lines.length;
     let s = params.start ?? 1;
     let e = Math.min(params.end ?? total, total);
@@ -1174,30 +1342,46 @@ Details: ${res.stderr}` : ""}`
       const content = lines[i - 1] ?? "";
       out.push(`${i}|${content}`);
     }
+    if (out.length > AGENT_CONFIG.MAX_READ_LINES) {
+      const truncated = out.slice(0, AGENT_CONFIG.MAX_READ_LINES);
+      truncated.push(`... [truncated: showing ${AGENT_CONFIG.MAX_READ_LINES} of ${out.length} lines]`);
+      return { lines: truncated };
+    }
     return { lines: out };
   }
-  async analyse(params) {
-    const abs = resolveUnderRepo(this.repoRoot, params.path);
+  async listDirectory(params) {
+    let abs;
+    try {
+      abs = resolveUnderRepo(this.repoRoot, params.path);
+    } catch {
+      return [];
+    }
     const stat = await import_promises2.default.stat(abs).catch(() => null);
     if (!stat || !stat.isDirectory()) {
       return [];
     }
-    const maxResults = params.maxResults ?? 100;
-    const maxDepth = params.maxDepth ?? 2;
+    const maxResults = params.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
+    const maxDepth = params.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
     const regex = params.pattern ? new RegExp(params.pattern) : null;
     const results = [];
+    let timedOut = false;
+    const startTime = Date.now();
     async function walk(dir, depth) {
+      if (Date.now() - startTime > AGENT_CONFIG.LIST_TIMEOUT_MS) {
+        timedOut = true;
+        return;
+      }
       if (depth > maxDepth || results.length >= maxResults) return;
       const entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const full = import_path3.default.join(dir, entry.name);
+        if (timedOut || results.length >= maxResults) break;
+        const full = import_path4.default.join(dir, entry.name);
         const rel = toRepoRelative(abs, full).replace(/^[.][/\\]?/, "");
-        if (DEFAULT_EXCLUDES.some((ex) => rel.split(import_path3.default.sep).includes(ex))) continue;
+        if (DEFAULT_EXCLUDES.some((ex) => rel.split(import_path4.default.sep).includes(ex))) continue;
         if (regex && !regex.test(entry.name)) continue;
-        if (results.length >= maxResults) break;
         results.push({
           name: entry.name,
-          path: toRepoRelative(import_path3.default.resolve(""), full),
+          path: toRepoRelative(import_path4.default.resolve(""), full),
           // relative display
           type: entry.isDirectory() ? "dir" : "file",
           depth
@@ -1212,10 +1396,121 @@ Details: ${res.stderr}` : ""}`
   }
 };
 
-// tools/warp_grep/prompts.ts
-var WARP_GREP_DESCRIPTION = 'IMPORTANT: If you need to explore the codebase to gather context, and the task does not involve a single file or function which is provided by name, you should ALWAYS use the warpgrep codebase search tool first instead of running search commands. When the task requires exploration beyond a single known file, invoke warpgrep first with a natural-language query describing the target functionality, bug, or architectural concern. Warp Grep is a fast and accurate tool that can search for all relevant context in a codebase. Keep queries action-oriented (e.g., "Find where billing invoices are generated and emailed"), and after reviewing the summarized results, you may verify important findings with other search tools or direct file reads to ensure completeness. Warp Grep can be used for query types like: find function responsible for <small feature>; find code that does <description>; find code path for <big feature>; Where does <minimal error message> come from?; or any query of that type. When a task requires exploration beyond a single known file, ALWAYS default to warpgrep codebase search before other search mechanisms.';
+// tools/warp_grep/providers/remote.ts
+var RemoteCommandsProvider = class {
+  constructor(repoRoot, commands) {
+    this.repoRoot = repoRoot;
+    this.commands = commands;
+  }
+  /**
+   * Run grep command and parse ripgrep output
+   */
+  async grep(params) {
+    try {
+      const stdout = await this.commands.grep(params.pattern, params.path, params.glob);
+      const lines = (stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
+      if (lines.length > AGENT_CONFIG.MAX_OUTPUT_LINES) {
+        return {
+          lines: [],
+          error: "Query not specific enough - too many results returned. Try a more specific pattern."
+        };
+      }
+      return { lines };
+    } catch (error) {
+      return {
+        lines: [],
+        error: `[GREP ERROR] ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Read file and add line numbers
+   */
+  async read(params) {
+    const start = params.start ?? 1;
+    const end = params.end ?? 1e6;
+    try {
+      const stdout = await this.commands.read(params.path, start, end);
+      const contentLines = (stdout || "").split("\n");
+      if (contentLines.length > 0 && contentLines[contentLines.length - 1] === "") {
+        contentLines.pop();
+      }
+      const lines = contentLines.map((content, idx) => `${start + idx}|${content}`);
+      if (lines.length > AGENT_CONFIG.MAX_READ_LINES) {
+        const truncated = lines.slice(0, AGENT_CONFIG.MAX_READ_LINES);
+        truncated.push(`... [truncated: showing ${AGENT_CONFIG.MAX_READ_LINES} of ${lines.length} lines]`);
+        return { lines: truncated };
+      }
+      return { lines };
+    } catch (error) {
+      return {
+        lines: [],
+        error: `[READ ERROR] ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * List directory and parse find output
+   */
+  async listDirectory(params) {
+    const maxDepth = params.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
+    const maxResults = params.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
+    try {
+      const stdout = await this.commands.listDir(params.path, maxDepth);
+      const paths = (stdout || "").trim().split(/\r?\n/).filter((p) => p.length > 0);
+      const regex = params.pattern ? new RegExp(params.pattern) : null;
+      const entries = [];
+      for (const fullPath of paths) {
+        if (fullPath === params.path || fullPath === this.repoRoot) continue;
+        const name = fullPath.split("/").pop() || "";
+        if (regex && !regex.test(name)) continue;
+        let relativePath = fullPath;
+        if (fullPath.startsWith(this.repoRoot)) {
+          relativePath = fullPath.slice(this.repoRoot.length).replace(/^\//, "");
+        }
+        const depth = relativePath.split("/").filter(Boolean).length - 1;
+        const hasExtension = name.includes(".") && !name.startsWith(".");
+        const type = hasExtension ? "file" : "dir";
+        entries.push({
+          name,
+          path: relativePath,
+          type,
+          depth: Math.max(0, depth)
+        });
+        if (entries.length >= maxResults) break;
+      }
+      return entries;
+    } catch (error) {
+      return [];
+    }
+  }
+};
 
-// tools/warp_grep/core.ts
+// tools/warp_grep/client.ts
+async function executeToolCall(input, config) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const provider = config.remoteCommands ? new RemoteCommandsProvider(config.repoRoot, config.remoteCommands) : 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,
+    morphApiKey: config.morphApiKey,
+    morphApiUrl: config.morphApiUrl,
+    retryConfig: config.retryConfig
+  });
+  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 formatResult(result) {
   if (!result.success) {
     return `Search failed: ${result.error}`;
@@ -1239,61 +1534,37 @@ function formatResult(result) {
   return lines.join("\n");
 }
 
+// tools/warp_grep/prompts.ts
+var WARP_GREP_DESCRIPTION = 'IMPORTANT: If you need to explore the codebase to gather context, and the task does not involve a single file or function which is provided by name, you should ALWAYS use the warpgrep codebase search tool first instead of running search commands. When the task requires exploration beyond a single known file, invoke warpgrep first with a natural-language query describing the target functionality, bug, or architectural concern. Warp Grep is a fast and accurate tool that can search for all relevant context in a codebase. Keep queries action-oriented (e.g., "Find where billing invoices are generated and emailed"), and after reviewing the summarized results, you may verify important findings with other search tools or direct file reads to ensure completeness. Warp Grep can be used for query types like: find function responsible for <small feature>; find code that does <description>; find code path for <big feature>; Where does <minimal error message> come from?; or any query of that type. When a task requires exploration beyond a single known file, ALWAYS default to warpgrep codebase search before other search mechanisms.';
+
 // tools/warp_grep/vercel.ts
-var warpGrepSchema = import_zod.z.object({
-  query: import_zod.z.string().describe("Free-form repository question")
-});
 async function execute(input, config) {
-  const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
-  const result = await runWarpGrep({
-    query: input.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 };
+  return executeToolCall(input, config);
 }
-function createMorphWarpGrepTool(config) {
+function createWarpGrepTool(config) {
+  const schema = import_zod.z.object({
+    query: import_zod.z.string().describe("Free-form repository question")
+  });
   return (0, import_ai.tool)({
     description: config.description ?? WARP_GREP_DESCRIPTION,
-    inputSchema: warpGrepSchema,
+    inputSchema: schema,
     execute: async (params) => {
-      const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
-      const result = await runWarpGrep({
-        query: params.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 result = await executeToolCall(params, config);
+      if (!result.success) {
+        throw new Error(`Failed to search codebase: ${result.error}`);
       }
-      const contexts = (finish.resolved ?? []).map((r) => ({
-        file: r.path,
-        content: r.content
-      }));
-      return { success: true, contexts, summary: finish.payload };
+      return {
+        success: true,
+        contexts: result.contexts,
+        summary: result.summary
+      };
     }
   });
 }
+var vercel_default = createWarpGrepTool;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createMorphWarpGrepTool,
+  createWarpGrepTool,
   execute,
   formatResult,
   getSystemPrompt