@morphllm/morphsdk 0.2.145 → 0.2.146

package/dist/tools/warp_grep/gemini.cjs

@@ -41,12 +41,11 @@ var init_config = __esm({
       return isNaN(parsed) || parsed <= 0 ? defaultMs : parsed;
     };
     AGENT_CONFIG = {
-      MAX_TURNS: 6,
+      MAX_TURNS: 4,
       /** Default timeout for model calls. Can be overridden via MORPH_WARP_GREP_TIMEOUT env var (in ms) */
       TIMEOUT_MS: parseEnvTimeout(process.env.MORPH_WARP_GREP_TIMEOUT, 3e4),
-      MAX_CONTEXT_CHARS: 321600,
+      MAX_CONTEXT_CHARS: 54e4,
       MAX_OUTPUT_LINES: 200,
-      MAX_LIST_RESULTS: 500,
       MAX_READ_LINES: 800,
       MAX_LIST_DEPTH: 3,
       LIST_TIMEOUT_MS: 2e3
@@ -131,7 +130,7 @@ var init_config = __esm({
       ".*"
     ];
     DEFAULT_EXCLUDES = (process.env.MORPH_WARP_GREP_EXCLUDE || "").split(",").map((s) => s.trim()).filter(Boolean).concat(BUILTIN_EXCLUDES);
-    DEFAULT_MODEL = "morph-warp-grep-v2.1";
+    DEFAULT_MODEL = "morph-warp-grep-v2";
   }
 });
 
@@ -204,19 +203,19 @@ var init_ripgrep = __esm({
 
 // tools/warp_grep/utils/paths.ts
 function resolveUnderRepo(repoRoot, targetPath) {
-  const absRoot = import_path4.default.resolve(repoRoot);
-  const resolved = import_path4.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_path4.default.relative(import_path4.default.resolve(repoRoot), import_path4.default.resolve(absTarget));
-  if (rel.startsWith("..") || import_path4.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_path4.default.relative(import_path4.default.resolve(repoRoot), import_path4.default.resolve(absPath));
+  return import_path3.default.relative(import_path3.default.resolve(repoRoot), import_path3.default.resolve(absPath));
 }
 function isSymlink(p) {
   try {
@@ -227,7 +226,7 @@ function isSymlink(p) {
   }
 }
 function fixPathRepetition(fullPath) {
-  const segments = fullPath.split(import_path4.default.sep).filter(Boolean);
+  const segments = fullPath.split(import_path3.default.sep).filter(Boolean);
   if (segments.length < 2) return null;
   for (let len = Math.floor(segments.length / 2); len >= 1; len--) {
     for (let i = 0; i <= segments.length - 2 * len; i++) {
@@ -235,7 +234,7 @@ function fixPathRepetition(fullPath) {
       const second = segments.slice(i + len, i + 2 * len);
       if (first.every((seg, idx) => seg === second[idx])) {
         const fixed = [...segments.slice(0, i), ...segments.slice(i + len)];
-        return import_path4.default.sep + fixed.join(import_path4.default.sep);
+        return import_path3.default.sep + fixed.join(import_path3.default.sep);
       }
     }
   }
@@ -259,12 +258,12 @@ function isTextualFile(filePath, maxBytes = 2e6) {
     return false;
   }
 }
-var import_fs, import_path4;
+var import_fs, import_path3;
 var init_paths = __esm({
   "tools/warp_grep/utils/paths.ts"() {
     "use strict";
     import_fs = __toESM(require("fs"), 1);
-    import_path4 = __toESM(require("path"), 1);
+    import_path3 = __toESM(require("path"), 1);
   }
 });
 
@@ -295,12 +294,12 @@ function shouldSkip2(name, allowNames) {
   }
   return false;
 }
-var import_promises2, import_path5, SKIP_NAMES2, SKIP_EXTENSIONS2, LocalRipgrepProvider;
+var import_promises2, import_path4, SKIP_NAMES2, SKIP_EXTENSIONS2, LocalRipgrepProvider;
 var init_local = __esm({
   "tools/warp_grep/providers/local.ts"() {
     "use strict";
     import_promises2 = __toESM(require("fs/promises"), 1);
-    import_path5 = __toESM(require("path"), 1);
+    import_path4 = __toESM(require("path"), 1);
     init_ripgrep();
     init_paths();
     init_files();
@@ -402,7 +401,7 @@ var init_local = __esm({
         }
         const stat = await import_promises2.default.stat(abs).catch(() => null);
         if (!stat) return { lines: [] };
-        const targetArg = abs === import_path5.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
+        const targetArg = abs === import_path4.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
         const contextLines = params.context_lines !== void 0 ? String(params.context_lines) : "1";
         const args = [
           "--no-config",
@@ -557,7 +556,7 @@ Details: ${res.stderr}` : ""}`
             if (timedOut || results.length >= maxResults) break;
             if (shouldSkip2(entry.name, allowNames)) continue;
             if (regex && !regex.test(entry.name)) continue;
-            const full = import_path5.default.join(dir, entry.name);
+            const full = import_path4.default.join(dir, entry.name);
             const isDir = entry.isDirectory();
             results.push({
               name: entry.name,
@@ -573,46 +572,6 @@ Details: ${res.stderr}` : ""}`
         await walk(abs, 0);
         return results;
       }
-      async glob(params) {
-        let abs;
-        try {
-          abs = params.path ? resolveUnderRepo(this.repoRoot, params.path) : this.repoRoot;
-        } catch (err) {
-          return { files: [], searchDir: this.repoRoot, totalFound: 0, error: `[PATH ERROR] ${err instanceof Error ? err.message : String(err)}` };
-        }
-        const stat = await import_promises2.default.stat(abs).catch(() => null);
-        if (!stat || !stat.isDirectory()) {
-          return { files: [], searchDir: abs, totalFound: 0, error: `[PATH ERROR] Directory not found: ${params.path || "."}` };
-        }
-        const targetArg = abs === import_path5.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
-        const args = [
-          "--no-config",
-          "--files",
-          "--color=never",
-          "-g",
-          params.pattern,
-          ...this.excludes.filter((e) => !this.allowNames?.has(e)).flatMap((e) => ["-g", `!${e}`]),
-          targetArg || "."
-        ];
-        const res = await runRipgrep(args, { cwd: this.repoRoot });
-        if (res.exitCode === -1) {
-          return { files: [], searchDir: abs, totalFound: 0, error: `[RIPGREP NOT AVAILABLE] ripgrep (rg) is required for glob search.` };
-        }
-        if (res.exitCode !== 0 && res.exitCode !== 1) {
-          return { files: [], searchDir: abs, totalFound: 0, error: `[GLOB ERROR] glob failed with exit code ${res.exitCode}${res.stderr ? `: ${res.stderr}` : ""}` };
-        }
-        const absRoot = import_path5.default.resolve(this.repoRoot);
-        const relFiles = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
-        const absFiles = relFiles.map((f) => import_path5.default.resolve(absRoot, f));
-        const withMtime = [];
-        for (const f of absFiles) {
-          const s = await import_promises2.default.stat(f).catch(() => null);
-          withMtime.push({ file: f, mtime: s?.mtimeMs ?? 0 });
-        }
-        withMtime.sort((a, b) => b.mtime - a.mtime);
-        const totalFound = withMtime.length;
-        return { files: withMtime.slice(0, 100).map((f) => f.file), searchDir: abs, totalFound };
-      }
     };
   }
 });
@@ -635,58 +594,131 @@ module.exports = __toCommonJS(gemini_exports);
 init_config();
 
 // tools/warp_grep/agent/parser.ts
-function parseReadLines(linesStr) {
-  const ranges = [];
-  for (const rangeStr of linesStr.split(",")) {
-    const trimmed = rangeStr.trim();
-    if (!trimmed) continue;
-    const parts = trimmed.split("-").map((v) => parseInt(v.trim(), 10));
-    if (parts.length >= 2 && Number.isFinite(parts[0]) && Number.isFinite(parts[1])) {
-      ranges.push([parts[0], parts[1]]);
-    } else if (Number.isFinite(parts[0])) {
-      ranges.push([parts[0], parts[0]]);
-    }
-  }
-  if (ranges.length === 1) return { start: ranges[0][0], end: ranges[0][1] };
-  if (ranges.length > 1) return { lines: ranges };
-  return {};
+var VALID_COMMANDS = ["list_directory", "ripgrep", "read", "finish"];
+function isValidCommand(name) {
+  return VALID_COMMANDS.includes(name);
 }
-function parseFinishFiles(filesStr) {
-  const files = [];
-  for (const line of filesStr.trim().split(/\s+/)) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    const colonIdx = trimmed.indexOf(":");
-    if (colonIdx === -1) {
-      files.push({ path: trimmed, lines: "*" });
-      continue;
+function parseQwen3ToolCalls(text) {
+  const tools = [];
+  const toolCallRegex = /<tool_call>\s*<function=([a-z_][a-z0-9_]*)>([\s\S]*?)<\/function>\s*<\/tool_call>/gi;
+  let match;
+  while ((match = toolCallRegex.exec(text)) !== null) {
+    const funcName = match[1].toLowerCase();
+    const body = match[2];
+    if (!isValidCommand(funcName)) continue;
+    const params = {};
+    const paramRegex = /<parameter=([a-z_][a-z0-9_]*)>([\s\S]*?)<\/parameter>/gi;
+    let paramMatch;
+    while ((paramMatch = paramRegex.exec(body)) !== null) {
+      params[paramMatch[1].toLowerCase()] = paramMatch[2].trim();
     }
-    const filePath = trimmed.slice(0, colonIdx);
-    const rangesPart = trimmed.slice(colonIdx + 1);
-    if (!rangesPart.trim() || rangesPart.trim() === "*") {
-      files.push({ path: filePath, lines: "*" });
-      continue;
-    }
-    const ranges = [];
-    for (const rangeStr of rangesPart.split(",")) {
-      const rt = rangeStr.trim();
-      if (!rt) continue;
-      const parts = rt.split("-").map((v) => parseInt(v.trim(), 10));
-      if (parts.length >= 2 && Number.isFinite(parts[0]) && Number.isFinite(parts[1])) {
-        ranges.push([parts[0], parts[1]]);
-      } else if (Number.isFinite(parts[0])) {
-        ranges.push([parts[0], parts[0]]);
+    if (funcName === "ripgrep") {
+      const pattern = params.pattern;
+      if (!pattern) continue;
+      const args = {
+        pattern,
+        path: params.path || ".",
+        ...params.glob && { glob: params.glob },
+        ...params.context_lines && { context_lines: parseInt(params.context_lines, 10) },
+        ...params.case_sensitive && { case_sensitive: params.case_sensitive === "true" }
+      };
+      tools.push({ name: "grep", arguments: args });
+    } else if (funcName === "list_directory") {
+      const command = params.command;
+      const directPath = params.path;
+      let dirPath = directPath || ".";
+      if (!directPath && command) {
+        const tokens = command.trim().split(/\s+/);
+        const pathTokens = tokens.slice(1).filter((t) => !t.startsWith("-") && !t.startsWith("|") && !t.startsWith("\\("));
+        if (pathTokens.length > 0) {
+          dirPath = pathTokens[0];
+        }
+      }
+      tools.push({ name: "list_directory", arguments: { path: dirPath, pattern: params.pattern || null } });
+    } else if (funcName === "read") {
+      const filePath = params.path;
+      if (!filePath) continue;
+      const args = { path: filePath };
+      const linesStr = params.lines;
+      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 (funcName === "finish") {
+      if (params.result && !params.files) {
+        tools.push({ name: "finish", arguments: { files: [], textResult: params.result } });
+        continue;
+      }
+      const filesStr = params.files;
+      if (!filesStr) {
+        tools.push({ name: "finish", arguments: { files: [], textResult: "No relevant code found." } });
+        continue;
+      }
+      const files = [];
+      for (const line of filesStr.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        const colonIdx = trimmed.indexOf(":");
+        if (colonIdx === -1) {
+          files.push({ path: trimmed, lines: "*" });
+        } else {
+          const filePath = trimmed.slice(0, colonIdx);
+          const rangesPart = trimmed.slice(colonIdx + 1);
+          const ranges = [];
+          for (const rangeStr of rangesPart.split(",")) {
+            const rt = rangeStr.trim();
+            if (!rt || rt === "*") {
+              files.push({ path: filePath, lines: "*" });
+              break;
+            }
+            const [s, e] = rt.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 > 0) {
+            files.push({ path: filePath, lines: ranges });
+          } else if (!files.some((f) => f.path === filePath)) {
+            files.push({ path: filePath, lines: "*" });
+          }
+        }
+      }
+      if (files.length > 0) {
+        tools.push({ name: "finish", arguments: { files } });
+      } else {
+        tools.push({ name: "finish", arguments: { files: [], textResult: filesStr } });
       }
     }
-    files.push({ path: filePath, lines: ranges.length > 0 ? ranges : "*" });
   }
-  return files;
-}
-function extractPathFromCommand(command) {
-  const tokens = command.trim().split(/\s+/);
-  const pathTokens = tokens.slice(1).filter((t) => !t.startsWith("-") && !t.startsWith("|") && !t.startsWith("\\("));
-  return pathTokens[0] || ".";
+  return tools;
 }
+var LLMResponseParser = class {
+  parse(text) {
+    if (typeof text !== "string") {
+      throw new TypeError("Command text must be a string.");
+    }
+    const withoutThink = text.replace(/<think>[\s\S]*?<\/think>/gi, "");
+    return parseQwen3ToolCalls(withoutThink);
+  }
+};
 
 // tools/warp_grep/agent/tools/grep.ts
 async function toolGrep(provider, args) {
@@ -737,42 +769,29 @@ async function toolRead(provider, args) {
 
 // tools/warp_grep/agent/tools/list_directory.ts
 init_config();
-var import_path = __toESM(require("path"), 1);
-async function toolListDirectory(provider, args, repoRoot) {
-  const maxResults = args.maxResults ?? AGENT_CONFIG.MAX_LIST_RESULTS;
-  const maxDepth = args.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
-  const entries = await provider.listDirectory({
-    path: args.path,
-    pattern: args.pattern ?? null,
-    maxResults,
-    maxDepth
-  });
-  if (!entries.length) return "empty";
-  if (repoRoot) {
-    const absRoot = import_path.default.resolve(repoRoot);
-    const lines = entries.map((e) => import_path.default.join(absRoot, e.path));
-    return lines.join("\n");
-  }
-  return entries.map((e) => e.path).join("\n");
-}
-
-// tools/warp_grep/agent/tools/glob.ts
-async function toolGlob(provider, args) {
-  const res = await provider.glob(args);
-  if (res.error) {
-    return res.error;
-  }
-  if (!res.files.length) {
-    return "no matches";
-  }
-  const header = `Found ${res.totalFound} file(s) matching "${args.pattern}" within ${res.searchDir}, sorted by modification time (newest first):`;
-  const body = res.files.join("\n");
-  const truncated = res.totalFound > res.files.length ? `
-[${res.totalFound - res.files.length} files truncated]` : "";
-  return `${header}
----
-${body}
----${truncated}`;
+async function toolListDirectory(provider, args) {
+  const maxResults = args.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
+  const initialDepth = args.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
+  async function getListRecursive(currentDepth) {
+    const entries = await provider.listDirectory({
+      path: args.path,
+      pattern: args.pattern ?? null,
+      maxResults,
+      maxDepth: currentDepth
+    });
+    if (entries.length >= maxResults && currentDepth > 0) {
+      return getListRecursive(currentDepth - 1);
+    }
+    return { entries };
+  }
+  const { entries: list } = await getListRecursive(initialDepth);
+  if (!list.length) return "empty";
+  const tree = list.map((e) => {
+    const indent = "  ".repeat(e.depth);
+    const name = e.type === "dir" ? `${e.name}/` : e.name;
+    return `${indent}${name}`;
+  }).join("\n");
+  return tree;
 }
 
 // tools/warp_grep/agent/tools/finish.ts
@@ -833,21 +852,32 @@ function mergeRanges(ranges) {
   return merged;
 }
 
-// tools/warp_grep/agent/helpers.ts
-var import_path2 = __toESM(require("path"), 1);
-init_config();
-var TRUNCATED_MARKER = "[truncated for context limit]";
-function getMessageSize(m) {
-  if (m.role === "tool") return m.content.length;
-  if (m.role === "assistant") {
-    let size = typeof m.content === "string" ? m.content.length : 0;
-    if (m.tool_calls) {
-      size += m.tool_calls.reduce((s, tc) => s + tc.function.name.length + tc.function.arguments.length, 0);
+// tools/warp_grep/agent/formatter.ts
+var ToolOutputFormatter = class {
+  format(toolName, _args, output, options = {}) {
+    const name = (toolName ?? "").trim();
+    if (!name) {
+      return "";
     }
-    return size;
+    const payload = output?.toString?.()?.trim?.() ?? "";
+    const isError = Boolean(options.isError);
+    if (!payload && !isError) {
+      return "";
+    }
+    return `<tool_response>
+${payload}
+</tool_response>`;
   }
-  return m.content.length;
+};
+var sharedFormatter = new ToolOutputFormatter();
+function formatAgentToolOutput(toolName, args, output, options = {}) {
+  return sharedFormatter.format(toolName, args, output, options);
 }
+
+// tools/warp_grep/agent/helpers.ts
+var import_path = __toESM(require("path"), 1);
+init_config();
+var TRUNCATED_MARKER = "[truncated for context limit]";
 function formatTurnMessage(turnsUsed, maxTurns) {
   const turnsRemaining = maxTurns - turnsUsed;
   if (turnsRemaining === 1) {
@@ -858,7 +888,7 @@ You have used ${turnsUsed} turns, you only have 1 turn remaining. You have run o
 You have used ${turnsUsed} turn${turnsUsed === 1 ? "" : "s"} and have ${turnsRemaining} remaining`;
 }
 function calculateContextBudget(messages) {
-  const totalChars = messages.reduce((sum, m) => sum + getMessageSize(m), 0);
+  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);
@@ -867,21 +897,24 @@ function calculateContextBudget(messages) {
 }
 async function buildInitialState(repoRoot, searchTerm, provider, options) {
   const budget = calculateContextBudget([]);
-  const turnTag = `You have used 0 turns and have ${AGENT_CONFIG.MAX_TURNS} remaining`;
+  const turnTag = `Turn 0/${AGENT_CONFIG.MAX_TURNS}`;
   const treeDepth = options?.search_type === "node_modules" ? 1 : 2;
-  const absRoot = import_path2.default.resolve(repoRoot);
   try {
     const entries = await provider.listDirectory({
       path: ".",
       maxResults: AGENT_CONFIG.MAX_OUTPUT_LINES,
       maxDepth: treeDepth
     });
-    const lines = [absRoot];
-    for (const e of entries) {
-      lines.push(import_path2.default.join(absRoot, e.path));
-    }
+    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>
-${lines.join("\n")}
+${treeOutput}
 </repo_structure>
 
 <search_string>
@@ -890,8 +923,9 @@ ${searchTerm}
 ${budget}
 ${turnTag}`;
   } catch {
+    const repoName = import_path.default.basename(repoRoot);
     return `<repo_structure>
-${absRoot}
+${repoName}/
 </repo_structure>
 
 <search_string>
@@ -902,32 +936,26 @@ ${turnTag}`;
   }
 }
 function enforceContextLimit(messages, maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS) {
-  const getTotalChars = () => messages.reduce((sum, m) => sum + getMessageSize(m), 0);
+  const getTotalChars = () => messages.reduce((sum, m) => sum + m.content.length, 0);
   if (getTotalChars() <= maxChars) {
     return messages;
   }
-  const truncatableIndices = [];
+  const userIndices = [];
   let firstUserSkipped = false;
   for (let i = 0; i < messages.length; i++) {
-    const m = messages[i];
-    if (m.role === "tool") {
-      truncatableIndices.push(i);
-    } else if (m.role === "user") {
+    if (messages[i].role === "user") {
       if (!firstUserSkipped) {
         firstUserSkipped = true;
         continue;
       }
-      truncatableIndices.push(i);
+      userIndices.push(i);
     }
   }
-  for (const idx of truncatableIndices) {
+  for (const idx of userIndices) {
     if (getTotalChars() <= maxChars) {
       break;
     }
-    const m = messages[idx];
-    if (m.role === "tool" && m.content !== TRUNCATED_MARKER) {
-      messages[idx] = { role: "tool", tool_call_id: m.tool_call_id, content: TRUNCATED_MARKER };
-    } else if (m.role === "user" && m.content !== TRUNCATED_MARKER) {
+    if (messages[idx].content !== TRUNCATED_MARKER) {
       messages[idx] = { role: "user", content: TRUNCATED_MARKER };
     }
   }
@@ -940,7 +968,7 @@ var import_openai = __toESM(require("openai"), 1);
 // package.json
 var package_default = {
   name: "@morphllm/morphsdk",
-  version: "0.2.145",
+  version: "0.2.146",
   description: "TypeScript SDK and CLI for Morph Fast Apply integration",
   type: "module",
   main: "./dist/index.cjs",
@@ -1179,115 +1207,9 @@ var package_default = {
 var SDK_VERSION = package_default.version;
 
 // tools/warp_grep/agent/runner.ts
-var import_path3 = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var parser = new LLMResponseParser();
 var DEFAULT_API_URL = "https://api.morphllm.com";
-var TOOL_SPECS = [
-  {
-    type: "function",
-    function: {
-      name: "list_directory",
-      description: "Execute ls or find commands to explore directory structure. Max 500 results. Common junk directories are excluded automatically.",
-      parameters: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "Full ls or find command (e.g. ls -la src/, find . -maxdepth 2 -type f -name '*.py', find . -type d, ls -d */)."
-          }
-        },
-        required: ["command"]
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "grep_search",
-      description: "Search for a regex pattern in file contents. Returns matching lines with file paths and line numbers. Case-insensitive. Respects .gitignore.",
-      parameters: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: "Regex pattern to search for in file contents (e.g. 'class\\s+\\w+Error', 'import|require|from', 'def (get|set|update)_user')."
-          },
-          path: {
-            type: "string",
-            description: "File or directory to search in. Defaults to current working directory."
-          },
-          glob: {
-            type: "string",
-            description: "Glob pattern to filter files (e.g. '*.py', '*.{ts,tsx,js,jsx,py,go}', 'src/**/*.go', '!*.test.*')."
-          },
-          limit: {
-            type: "integer",
-            description: "Limit output to first N matching lines. Shows all matches if not specified."
-          }
-        },
-        required: ["pattern"]
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "glob",
-      description: "Find files by name/extension using glob patterns. Returns absolute paths sorted by modification time (newest first). Respects .gitignore. Max 100 results.",
-      parameters: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: "Glob pattern to match files (e.g. '*.py', 'src/**/*.js', '*.{ts,tsx}', 'test_*.py')."
-          },
-          path: {
-            type: "string",
-            description: "Directory to search in. Defaults to repository root."
-          }
-        },
-        required: ["pattern"]
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "read",
-      description: "Read entire files or specific line ranges using absolute paths.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "File path to read, using absolute path (e.g. '/home/ubuntu/repo/src/main.py' or windows path)."
-          },
-          lines: {
-            type: "string",
-            description: "Optional line range (e.g. '1-50' or '1-20,45-80'). Omit to read entire file."
-          }
-        },
-        required: ["path"]
-      }
-    }
-  },
-  {
-    type: "function",
-    function: {
-      name: "finish",
-      description: "Submit final answer with all relevant code locations. Include imports and over-include rather than miss context.",
-      parameters: {
-        type: "object",
-        properties: {
-          files: {
-            type: "string",
-            description: "One file per line as path:lines (e.g. 'src/auth.py:1-15,25-50\\nsrc/user.py'). Omit line range to include entire file."
-          }
-        },
-        required: ["files"]
-      }
-    }
-  }
-];
 async function callModel(messages, model, options = {}) {
   const baseUrl = options.morphApiUrl || DEFAULT_API_URL;
   const apiKey = options.morphApiKey || process.env.MORPH_API_KEY || "";
@@ -1308,9 +1230,8 @@ async function callModel(messages, model, options = {}) {
       data = await client.chat.completions.create({
         model,
         temperature: 0,
-        max_tokens: 2048,
+        max_tokens: 1024,
         messages,
-        tools: TOOL_SPECS,
         ...options.search_type ? { search_type: options.search_type } : {}
       });
     } catch (error) {
@@ -1322,87 +1243,187 @@ async function callModel(messages, model, options = {}) {
       throw error;
     }
     const choice = data?.choices?.[0];
-    const message = choice?.message;
-    if (!message) {
-      if (attempt === MAX_EMPTY_RETRIES) {
-        throw new Error("Invalid response from model: no message in response");
-      }
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      continue;
-    }
-    const toolCalls = (message.tool_calls || []).map((tc) => ({
-      id: tc.id,
-      type: "function",
-      function: { name: tc.function.name, arguments: tc.function.arguments }
-    }));
-    if (message.content || toolCalls.length > 0) {
-      return { content: message.content ?? null, tool_calls: toolCalls };
+    const content = choice?.message?.content;
+    if (content && typeof content === "string") {
+      return content;
     }
     if (attempt === MAX_EMPTY_RETRIES) {
       const finishReason = choice?.finish_reason ?? "unknown";
+      const hasToolCalls = Array.isArray(choice?.message?.tool_calls) && choice.message.tool_calls.length > 0;
+      const choicesLen = data?.choices?.length ?? 0;
+      const contentType = content === null ? "null" : content === void 0 ? "undefined" : typeof content;
       throw new Error(
-        `Invalid response from model: no content and no tool_calls, finish_reason=${finishReason}`
+        `Invalid response from model: content=${contentType}, finish_reason=${finishReason}, has_tool_calls=${hasToolCalls}, choices_length=${choicesLen}`
       );
     }
     await new Promise((resolve) => setTimeout(resolve, 200));
   }
   throw new Error("Invalid response from model");
 }
-function safeParseJSON(s) {
-  try {
-    return JSON.parse(s);
-  } catch {
-    return {};
-  }
-}
-async function executeTool(provider, name, args, repoRoot) {
-  switch (name) {
-    case "grep_search": {
-      const grepArgs = {
-        pattern: args.pattern,
-        path: args.path || "."
-      };
-      if (args.glob) grepArgs.glob = args.glob;
-      if (args.case_sensitive !== void 0) grepArgs.case_sensitive = args.case_sensitive;
-      const result = await toolGrep(provider, grepArgs);
-      let output = result.output;
-      if (args.limit && typeof args.limit === "number") {
-        const lines = output.split("\n");
-        if (lines.length > args.limit) {
-          output = lines.slice(0, args.limit).join("\n") + `
-... (truncated at ${args.limit} lines)`;
-        }
-      }
-      return output;
+async function runWarpGrep(config) {
+  const totalStart = Date.now();
+  const timeoutMs = config.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
+  const timings = { turns: [], timeout_ms: timeoutMs };
+  const repoRoot = import_path2.default.resolve(config.repoRoot || process.cwd());
+  const model = config.model || DEFAULT_MODEL;
+  const messages = [];
+  const maxTurns = AGENT_CONFIG.MAX_TURNS;
+  const initialStateStart = Date.now();
+  const initialState = await buildInitialState(repoRoot, config.searchTerm, config.provider, { search_type: config.search_type });
+  timings.initial_state_ms = Date.now() - initialStateStart;
+  messages.push({ role: "user", content: initialState });
+  const provider = config.provider;
+  const errors = [];
+  let finishMeta;
+  let terminationReason = "terminated";
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    const turnMetrics = { turn, morph_api_ms: 0, local_tools_ms: 0 };
+    enforceContextLimit(messages);
+    const modelCallStart = Date.now();
+    const assistantContent = await callModel(messages, model, {
+      morphApiKey: config.morphApiKey,
+      morphApiUrl: config.morphApiUrl,
+      retryConfig: config.retryConfig,
+      timeout: timeoutMs,
+      search_type: config.search_type
+    }).catch((e) => {
+      const errMsg = e instanceof Error ? e.message : String(e);
+      console.error(`[warp_grep] Morph API call failed on turn ${turn}:`, errMsg);
+      errors.push({ message: errMsg });
+      return "";
+    });
+    turnMetrics.morph_api_ms = Date.now() - modelCallStart;
+    if (!assistantContent) {
+      console.error(`[warp_grep] Empty response from Morph API on turn ${turn}. Errors so far:`, errors);
+      timings.turns.push(turnMetrics);
+      break;
     }
-    case "glob": {
-      return toolGlob(provider, {
-        pattern: args.pattern,
-        path: args.path
-      });
+    messages.push({ role: "assistant", content: assistantContent });
+    const toolCalls = parser.parse(assistantContent);
+    if (toolCalls.length === 0) {
+      console.error(`[warp_grep] No tool calls parsed on turn ${turn}. Assistant content (first 500 chars):`, assistantContent.slice(0, 500));
+      errors.push({ message: "No tool calls produced by the model. Your MCP is likely out of date! Update it by running: rm -rf ~/.npm/_npx && npm cache clean --force && npx -y @morphllm/morphmcp@latest" });
+      terminationReason = "terminated";
+      timings.turns.push(turnMetrics);
+      break;
     }
-    case "list_directory": {
-      const dirPath = extractPathFromCommand(args.command || ".");
-      return toolListDirectory(provider, { path: dirPath }, repoRoot);
+    const finishCalls = toolCalls.filter((c) => c.name === "finish");
+    const grepCalls = toolCalls.filter((c) => c.name === "grep");
+    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 = [];
+    for (const c of skipCalls) {
+      const msg = c.arguments?.message || "Command skipped due to parsing error";
+      formatted.push(msg);
     }
-    case "read": {
-      const readArgs = {
-        path: args.path
-      };
-      if (args.lines && typeof args.lines === "string") {
-        Object.assign(readArgs, parseReadLines(args.lines));
+    const allPromises = [];
+    for (const c of grepCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolGrep(provider, args).then(
+          ({ output }) => formatAgentToolOutput("grep", args, output),
+          (err) => formatAgentToolOutput("grep", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of listDirCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolListDirectory(provider, args).then(
+          (p) => formatAgentToolOutput("list_directory", args, p),
+          (err) => formatAgentToolOutput("list_directory", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of readCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolRead(provider, args).then(
+          (p) => formatAgentToolOutput("read", args, p),
+          (err) => formatAgentToolOutput("read", args, String(err), { isError: true })
+        )
+      );
+    }
+    const toolExecStart = Date.now();
+    const allResults = await Promise.all(allPromises);
+    turnMetrics.local_tools_ms = Date.now() - toolExecStart;
+    for (const result of allResults) {
+      formatted.push(result);
+    }
+    if (formatted.length > 0) {
+      const turnMessage = formatTurnMessage(turn, maxTurns);
+      const contextBudget = calculateContextBudget(messages);
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
+    }
+    timings.turns.push(turnMetrics);
+    if (finishCalls.length) {
+      const fc = finishCalls[0];
+      const files = fc.arguments?.files ?? [];
+      const textResult = fc.arguments?.textResult;
+      finishMeta = { files };
+      terminationReason = "completed";
+      if (files.length === 0) {
+        const payload2 = textResult || "No relevant code found.";
+        timings.turns.push(turnMetrics);
+        timings.total_ms = Date.now() - totalStart;
+        return {
+          terminationReason: "completed",
+          messages,
+          finish: { payload: payload2, metadata: finishMeta },
+          timings
+        };
+      }
+      break;
+    }
+  }
+  if (terminationReason !== "completed" || !finishMeta) {
+    timings.total_ms = Date.now() - totalStart;
+    return { terminationReason, messages, errors, timings };
+  }
+  const parts = ["Relevant context found:"];
+  for (const f of finishMeta.files) {
+    const ranges = f.lines === "*" ? "*" : Array.isArray(f.lines) ? f.lines.map(([s, e]) => `${s}-${e}`).join(", ") : "*";
+    parts.push(`- ${f.path}: ${ranges}`);
+  }
+  const payload = parts.join("\n");
+  const finishResolutionStart = Date.now();
+  const fileReadErrors = [];
+  const resolved = await readFinishFiles(
+    repoRoot,
+    finishMeta.files,
+    async (p, s, e) => {
+      try {
+        const rr = await provider.read({ path: p, start: s, end: e });
+        return rr.lines.map((l) => {
+          const idx = l.indexOf("|");
+          return idx >= 0 ? l.slice(idx + 1) : l;
+        });
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        fileReadErrors.push({ path: p, error: errorMsg });
+        console.error(`[warp_grep] Failed to read file: ${p} - ${errorMsg}`);
+        return [`[couldn't find: ${p}]`];
       }
-      return toolRead(provider, readArgs);
     }
-    default:
-      return `Unknown tool: ${name}`;
+  );
+  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
+  if (fileReadErrors.length > 0) {
+    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
   }
+  timings.total_ms = Date.now() - totalStart;
+  return {
+    terminationReason: "completed",
+    messages,
+    finish: { payload, metadata: finishMeta, resolved },
+    timings
+  };
 }
 async function* runWarpGrepStreaming(config) {
   const totalStart = Date.now();
   const timeoutMs = config.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
   const timings = { turns: [], timeout_ms: timeoutMs };
-  const repoRoot = import_path3.default.resolve(config.repoRoot || process.cwd());
+  const repoRoot = import_path2.default.resolve(config.repoRoot || process.cwd());
   const model = config.model || DEFAULT_MODEL;
   const messages = [];
   const maxTurns = AGENT_CONFIG.MAX_TURNS;
@@ -1418,7 +1439,7 @@ async function* runWarpGrepStreaming(config) {
     const turnMetrics = { turn, morph_api_ms: 0, local_tools_ms: 0 };
     enforceContextLimit(messages);
     const modelCallStart = Date.now();
-    const response = await callModel(messages, model, {
+    const assistantContent = await callModel(messages, model, {
       morphApiKey: config.morphApiKey,
       morphApiUrl: config.morphApiUrl,
       retryConfig: config.retryConfig,
@@ -1426,45 +1447,90 @@ async function* runWarpGrepStreaming(config) {
       search_type: config.search_type
     }).catch((e) => {
       const errMsg = e instanceof Error ? e.message : String(e);
-      console.error(`[warp_grep] Morph API call failed on turn ${turn}:`, errMsg);
+      console.error(`[warp_grep:stream] Morph API call failed on turn ${turn}:`, errMsg);
       errors.push({ message: errMsg });
-      return null;
+      return "";
     });
     turnMetrics.morph_api_ms = Date.now() - modelCallStart;
-    if (!response) {
+    if (!assistantContent) {
+      console.error(`[warp_grep:stream] Empty response from Morph API on turn ${turn}. Errors so far:`, errors);
       timings.turns.push(turnMetrics);
       break;
     }
-    const toolCalls = response.tool_calls;
-    messages.push({
-      role: "assistant",
-      content: response.content,
-      ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
-    });
+    messages.push({ role: "assistant", content: assistantContent });
+    const toolCalls = parser.parse(assistantContent);
     if (toolCalls.length === 0) {
-      console.error(`[warp_grep] No tool calls on turn ${turn}. Content: ${(response.content || "").slice(0, 500)}`);
-      errors.push({ message: "No tool calls produced by the model." });
+      console.error(`[warp_grep:stream] No tool calls parsed on turn ${turn}. Assistant content (first 500 chars):`, assistantContent.slice(0, 500));
+      errors.push({ message: "No tool calls produced by the model. Your MCP is likely out of date! Update it by running: rm -rf ~/.npm/_npx && npm cache clean --force && npx -y @morphllm/morphmcp@latest" });
       terminationReason = "terminated";
       timings.turns.push(turnMetrics);
       break;
     }
     yield {
       turn,
-      toolCalls: toolCalls.map((tc) => ({
-        name: tc.function.name,
-        arguments: safeParseJSON(tc.function.arguments)
+      toolCalls: toolCalls.map((c) => ({
+        name: c.name,
+        arguments: c.arguments ?? {}
       }))
     };
-    const finishCall = toolCalls.find((tc) => tc.function.name === "finish");
-    if (finishCall) {
-      const args = safeParseJSON(finishCall.function.arguments);
-      const filesStr = args.files || "";
-      const files = parseFinishFiles(filesStr);
+    const finishCalls = toolCalls.filter((c) => c.name === "finish");
+    const grepCalls = toolCalls.filter((c) => c.name === "grep");
+    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 = [];
+    for (const c of skipCalls) {
+      const msg = c.arguments?.message || "Command skipped due to parsing error";
+      formatted.push(msg);
+    }
+    const allPromises = [];
+    for (const c of grepCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolGrep(provider, args).then(
+          ({ output }) => formatAgentToolOutput("grep", args, output),
+          (err) => formatAgentToolOutput("grep", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of listDirCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolListDirectory(provider, args).then(
+          (p) => formatAgentToolOutput("list_directory", args, p),
+          (err) => formatAgentToolOutput("list_directory", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of readCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolRead(provider, args).then(
+          (p) => formatAgentToolOutput("read", args, p),
+          (err) => formatAgentToolOutput("read", args, String(err), { isError: true })
+        )
+      );
+    }
+    const toolExecStart = Date.now();
+    const allResults = await Promise.all(allPromises);
+    turnMetrics.local_tools_ms = Date.now() - toolExecStart;
+    for (const result of allResults) {
+      formatted.push(result);
+    }
+    if (formatted.length > 0) {
+      const turnMessage = formatTurnMessage(turn, maxTurns);
+      const contextBudget = calculateContextBudget(messages);
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
+    }
+    timings.turns.push(turnMetrics);
+    if (finishCalls.length) {
+      const fc = finishCalls[0];
+      const files = fc.arguments?.files ?? [];
+      const textResult = fc.arguments?.textResult;
       finishMeta = { files };
       terminationReason = "completed";
       if (files.length === 0) {
-        const payload2 = filesStr || "No relevant code found.";
-        timings.turns.push(turnMetrics);
+        const payload2 = textResult || "No relevant code found.";
         timings.total_ms = Date.now() - totalStart;
         return {
           terminationReason: "completed",
@@ -1473,25 +1539,8 @@ async function* runWarpGrepStreaming(config) {
           timings
         };
       }
-      timings.turns.push(turnMetrics);
       break;
     }
-    const toolExecStart = Date.now();
-    const results = await Promise.all(
-      toolCalls.map(async (tc) => {
-        const args = safeParseJSON(tc.function.arguments);
-        const output = await executeTool(provider, tc.function.name, args, repoRoot).catch((err) => String(err));
-        return { tool_call_id: tc.id, content: output };
-      })
-    );
-    turnMetrics.local_tools_ms = Date.now() - toolExecStart;
-    for (const result of results) {
-      messages.push({ role: "tool", tool_call_id: result.tool_call_id, content: result.content });
-    }
-    const turnMsg = formatTurnMessage(turn, maxTurns);
-    const budget = calculateContextBudget(messages);
-    messages.push({ role: "user", content: turnMsg + "\n" + budget });
-    timings.turns.push(turnMetrics);
   }
   if (terminationReason !== "completed" || !finishMeta) {
     timings.total_ms = Date.now() - totalStart;
@@ -1535,14 +1584,6 @@ async function* runWarpGrepStreaming(config) {
     timings
   };
 }
-async function runWarpGrep(config) {
-  const gen = runWarpGrepStreaming(config);
-  let result = await gen.next();
-  while (!result.done) {
-    result = await gen.next();
-  }
-  return result.value;
-}
 
 // tools/warp_grep/providers/remote.ts
 init_config();
@@ -1722,35 +1763,6 @@ var RemoteCommandsProvider = class {
       return [];
     }
   }
-  /**
-   * Glob search - finds files matching a pattern.
-   * Falls back to a grep --files approach via the listDir command.
-   */
-  async glob(params) {
-    const searchPath = params.path || this.repoRoot;
-    try {
-      const stdout = await this.commands.listDir(searchPath, 10);
-      const allPaths = (stdout || "").trim().split(/\r?\n/).filter((p) => p.length > 0);
-      const globToRegex = (glob) => {
-        const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-        return new RegExp(escaped);
-      };
-      const regex = globToRegex(params.pattern);
-      const matched = allPaths.filter((p) => {
-        const name = p.split("/").pop() || "";
-        return regex.test(name) && !shouldSkip(name);
-      });
-      const totalFound = matched.length;
-      return { files: matched.slice(0, 100), searchDir: searchPath, totalFound };
-    } catch (error) {
-      return {
-        files: [],
-        searchDir: searchPath,
-        totalFound: 0,
-        error: `[GLOB ERROR] ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
 };
 
 // tools/warp_grep/providers/code_storage_http.ts
@@ -1777,9 +1789,9 @@ function createCodeStorageHttpCommands(config) {
   const { baseUrl, repoId, branch } = config;
   const encodedRepoId = encodeURIComponent(repoId);
   return {
-    grep: (pattern, path6, glob) => post(`${baseUrl}/api/code-search/${encodedRepoId}/grep`, { pattern, path: path6, glob, branch }, "grep"),
-    read: (path6, start, end) => post(`${baseUrl}/api/code-search/${encodedRepoId}/read`, { path: path6, start, end, branch }, "read"),
-    listDir: (path6, maxDepth) => post(`${baseUrl}/api/code-search/${encodedRepoId}/list`, { path: path6, maxDepth, branch }, "list")
+    grep: (pattern, path5, glob) => post(`${baseUrl}/api/code-search/${encodedRepoId}/grep`, { pattern, path: path5, glob, branch }, "grep"),
+    read: (path5, start, end) => post(`${baseUrl}/api/code-search/${encodedRepoId}/read`, { path: path5, start, end, branch }, "read"),
+    listDir: (path5, maxDepth) => post(`${baseUrl}/api/code-search/${encodedRepoId}/list`, { path: path5, maxDepth, branch }, "list")
   };
 }