@morphllm/morphsdk 0.2.146 → 0.2.148

package/dist/subagents/anthropic.cjs

@@ -41,11 +41,12 @@ var init_config = __esm({
       return isNaN(parsed) || parsed <= 0 ? defaultMs : parsed;
     };
     AGENT_CONFIG = {
-      MAX_TURNS: 4,
+      MAX_TURNS: 6,
       /** 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: 54e4,
+      MAX_CONTEXT_CHARS: 321600,
       MAX_OUTPUT_LINES: 200,
+      MAX_LIST_RESULTS: 500,
       MAX_READ_LINES: 800,
       MAX_LIST_DEPTH: 3,
       LIST_TIMEOUT_MS: 2e3
@@ -130,7 +131,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";
+    DEFAULT_MODEL = "morph-warp-grep-v2.1";
   }
 });
 
@@ -203,19 +204,19 @@ var init_ripgrep = __esm({
 
 // tools/warp_grep/utils/paths.ts
 function resolveUnderRepo(repoRoot, targetPath) {
-  const absRoot = import_path3.default.resolve(repoRoot);
-  const resolved = import_path3.default.resolve(absRoot, targetPath);
+  const absRoot = import_path4.default.resolve(repoRoot);
+  const resolved = import_path4.default.resolve(absRoot, targetPath);
   ensureWithinRepo(absRoot, resolved);
   return resolved;
 }
 function ensureWithinRepo(repoRoot, absTarget) {
-  const rel = import_path3.default.relative(import_path3.default.resolve(repoRoot), import_path3.default.resolve(absTarget));
-  if (rel.startsWith("..") || import_path3.default.isAbsolute(rel)) {
+  const rel = import_path4.default.relative(import_path4.default.resolve(repoRoot), import_path4.default.resolve(absTarget));
+  if (rel.startsWith("..") || import_path4.default.isAbsolute(rel)) {
     throw new Error(`Path outside repository root: ${absTarget}`);
   }
 }
 function toRepoRelative(repoRoot, absPath) {
-  return import_path3.default.relative(import_path3.default.resolve(repoRoot), import_path3.default.resolve(absPath));
+  return import_path4.default.relative(import_path4.default.resolve(repoRoot), import_path4.default.resolve(absPath));
 }
 function isSymlink(p) {
   try {
@@ -226,7 +227,7 @@ function isSymlink(p) {
   }
 }
 function fixPathRepetition(fullPath) {
-  const segments = fullPath.split(import_path3.default.sep).filter(Boolean);
+  const segments = fullPath.split(import_path4.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++) {
@@ -234,7 +235,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_path3.default.sep + fixed.join(import_path3.default.sep);
+        return import_path4.default.sep + fixed.join(import_path4.default.sep);
       }
     }
   }
@@ -258,12 +259,12 @@ function isTextualFile(filePath, maxBytes = 2e6) {
     return false;
   }
 }
-var import_fs, import_path3;
+var import_fs, import_path4;
 var init_paths = __esm({
   "tools/warp_grep/utils/paths.ts"() {
     "use strict";
     import_fs = __toESM(require("fs"), 1);
-    import_path3 = __toESM(require("path"), 1);
+    import_path4 = __toESM(require("path"), 1);
   }
 });
 
@@ -294,12 +295,12 @@ function shouldSkip2(name, allowNames) {
   }
   return false;
 }
-var import_promises2, import_path4, SKIP_NAMES2, SKIP_EXTENSIONS2, LocalRipgrepProvider;
+var import_promises2, import_path5, 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_path4 = __toESM(require("path"), 1);
+    import_path5 = __toESM(require("path"), 1);
     init_ripgrep();
     init_paths();
     init_files();
@@ -401,7 +402,7 @@ var init_local = __esm({
         }
         const stat = await import_promises2.default.stat(abs).catch(() => null);
         if (!stat) return { lines: [] };
-        const targetArg = abs === import_path4.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
+        const targetArg = abs === import_path5.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
         const contextLines = params.context_lines !== void 0 ? String(params.context_lines) : "1";
         const args = [
           "--no-config",
@@ -556,7 +557,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_path4.default.join(dir, entry.name);
+            const full = import_path5.default.join(dir, entry.name);
             const isDir = entry.isDirectory();
             results.push({
               name: entry.name,
@@ -572,6 +573,46 @@ 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 };
+      }
     };
   }
 });
@@ -587,131 +628,58 @@ module.exports = __toCommonJS(anthropic_exports);
 init_config();
 
 // tools/warp_grep/agent/parser.ts
-var VALID_COMMANDS = ["list_directory", "ripgrep", "read", "finish"];
-function isValidCommand(name) {
-  return VALID_COMMANDS.includes(name);
+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 {};
 }
-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();
+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;
     }
-    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 } });
+    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]]);
       }
     }
+    files.push({ path: filePath, lines: ranges.length > 0 ? ranges : "*" });
   }
-  return tools;
+  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] || ".";
 }
-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) {
@@ -762,29 +730,42 @@ async function toolRead(provider, args) {
 
 // tools/warp_grep/agent/tools/list_directory.ts
 init_config();
-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;
+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}`;
 }
 
 // tools/warp_grep/agent/tools/finish.ts
@@ -845,32 +826,21 @@ function mergeRanges(ranges) {
   return merged;
 }
 
-// tools/warp_grep/agent/formatter.ts
-var ToolOutputFormatter = class {
-  format(toolName, _args, output, options = {}) {
-    const name = (toolName ?? "").trim();
-    if (!name) {
-      return "";
-    }
-    const payload = output?.toString?.()?.trim?.() ?? "";
-    const isError = Boolean(options.isError);
-    if (!payload && !isError) {
-      return "";
-    }
-    return `<tool_response>
-${payload}
-</tool_response>`;
-  }
-};
-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);
+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);
+    }
+    return size;
+  }
+  return m.content.length;
+}
 function formatTurnMessage(turnsUsed, maxTurns) {
   const turnsRemaining = maxTurns - turnsUsed;
   if (turnsRemaining === 1) {
@@ -881,33 +851,30 @@ 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 + m.content.length, 0);
+  const totalChars = messages.reduce((sum, m) => sum + getMessageSize(m), 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 used)</context_budget>`;
+  const percent = Math.floor(totalChars / maxChars * 100);
+  const usedK = Math.floor(totalChars / 1e3);
+  const maxK = Math.floor(maxChars / 1e3);
+  return `<context_budget>${percent}% (${usedK}K/${maxK}K chars)</context_budget>`;
 }
 async function buildInitialState(repoRoot, searchTerm, provider, options) {
   const budget = calculateContextBudget([]);
-  const turnTag = `Turn 0/${AGENT_CONFIG.MAX_TURNS}`;
+  const turnTag = `You have used 0 turns and have ${AGENT_CONFIG.MAX_TURNS} remaining`;
   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 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}/`;
+    const lines = [absRoot];
+    for (const e of entries) {
+      lines.push(import_path2.default.join(absRoot, e.path));
+    }
     return `<repo_structure>
-${treeOutput}
+${lines.join("\n")}
 </repo_structure>
 
 <search_string>
@@ -916,9 +883,8 @@ ${searchTerm}
 ${budget}
 ${turnTag}`;
   } catch {
-    const repoName = import_path.default.basename(repoRoot);
     return `<repo_structure>
-${repoName}/
+${absRoot}
 </repo_structure>
 
 <search_string>
@@ -929,26 +895,32 @@ ${turnTag}`;
   }
 }
 function enforceContextLimit(messages, maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS) {
-  const getTotalChars = () => messages.reduce((sum, m) => sum + m.content.length, 0);
+  const getTotalChars = () => messages.reduce((sum, m) => sum + getMessageSize(m), 0);
   if (getTotalChars() <= maxChars) {
     return messages;
   }
-  const userIndices = [];
+  const truncatableIndices = [];
   let firstUserSkipped = false;
   for (let i = 0; i < messages.length; i++) {
-    if (messages[i].role === "user") {
+    const m = messages[i];
+    if (m.role === "tool") {
+      truncatableIndices.push(i);
+    } else if (m.role === "user") {
       if (!firstUserSkipped) {
         firstUserSkipped = true;
         continue;
       }
-      userIndices.push(i);
+      truncatableIndices.push(i);
     }
   }
-  for (const idx of userIndices) {
+  for (const idx of truncatableIndices) {
     if (getTotalChars() <= maxChars) {
       break;
     }
-    if (messages[idx].content !== TRUNCATED_MARKER) {
+    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) {
       messages[idx] = { role: "user", content: TRUNCATED_MARKER };
     }
   }
@@ -961,7 +933,7 @@ var import_openai = __toESM(require("openai"), 1);
 // package.json
 var package_default = {
   name: "@morphllm/morphsdk",
-  version: "0.2.146",
+  version: "0.2.148",
   description: "TypeScript SDK and CLI for Morph Fast Apply integration",
   type: "module",
   main: "./dist/index.cjs",
@@ -1200,9 +1172,115 @@ var package_default = {
 var SDK_VERSION = package_default.version;
 
 // tools/warp_grep/agent/runner.ts
-var import_path2 = __toESM(require("path"), 1);
-var parser = new LLMResponseParser();
+var import_path3 = __toESM(require("path"), 1);
 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 || "";
@@ -1223,8 +1301,9 @@ async function callModel(messages, model, options = {}) {
       data = await client.chat.completions.create({
         model,
         temperature: 0,
-        max_tokens: 1024,
+        max_tokens: 2048,
         messages,
+        tools: TOOL_SPECS,
         ...options.search_type ? { search_type: options.search_type } : {}
       });
     } catch (error) {
@@ -1236,187 +1315,87 @@ async function callModel(messages, model, options = {}) {
       throw error;
     }
     const choice = data?.choices?.[0];
-    const content = choice?.message?.content;
-    if (content && typeof content === "string") {
-      return content;
+    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 };
     }
     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: content=${contentType}, finish_reason=${finishReason}, has_tool_calls=${hasToolCalls}, choices_length=${choicesLen}`
+        `Invalid response from model: no content and no tool_calls, finish_reason=${finishReason}`
       );
     }
     await new Promise((resolve) => setTimeout(resolve, 200));
   }
   throw new Error("Invalid response from model");
 }
-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;
-    }
-    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;
-    }
-    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 })
-        )
-      );
+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;
     }
-    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);
+    case "glob": {
+      return toolGlob(provider, {
+        pattern: args.pattern,
+        path: args.path
+      });
     }
-    if (formatted.length > 0) {
-      const turnMessage = formatTurnMessage(turn, maxTurns);
-      const contextBudget = calculateContextBudget(messages);
-      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
+    case "list_directory": {
+      const dirPath = extractPathFromCommand(args.command || ".");
+      return toolListDirectory(provider, { path: dirPath }, repoRoot);
     }
-    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}]`];
+    case "read": {
+      const readArgs = {
+        path: args.path
+      };
+      if (args.lines && typeof args.lines === "string") {
+        Object.assign(readArgs, parseReadLines(args.lines));
       }
+      return toolRead(provider, readArgs);
     }
-  );
-  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
-  if (fileReadErrors.length > 0) {
-    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
+    default:
+      return `Unknown tool: ${name}`;
   }
-  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_path2.default.resolve(config.repoRoot || process.cwd());
+  const repoRoot = import_path3.default.resolve(config.repoRoot || process.cwd());
   const model = config.model || DEFAULT_MODEL;
   const messages = [];
   const maxTurns = AGENT_CONFIG.MAX_TURNS;
@@ -1432,7 +1411,7 @@ async function* runWarpGrepStreaming(config) {
     const turnMetrics = { turn, morph_api_ms: 0, local_tools_ms: 0 };
     enforceContextLimit(messages);
     const modelCallStart = Date.now();
-    const assistantContent = await callModel(messages, model, {
+    const response = await callModel(messages, model, {
       morphApiKey: config.morphApiKey,
       morphApiUrl: config.morphApiUrl,
       retryConfig: config.retryConfig,
@@ -1440,90 +1419,45 @@ async function* runWarpGrepStreaming(config) {
       search_type: config.search_type
     }).catch((e) => {
       const errMsg = e instanceof Error ? e.message : String(e);
-      console.error(`[warp_grep:stream] Morph API call failed on turn ${turn}:`, errMsg);
+      console.error(`[warp_grep] Morph API call failed on turn ${turn}:`, errMsg);
       errors.push({ message: errMsg });
-      return "";
+      return null;
     });
     turnMetrics.morph_api_ms = Date.now() - modelCallStart;
-    if (!assistantContent) {
-      console.error(`[warp_grep:stream] Empty response from Morph API on turn ${turn}. Errors so far:`, errors);
+    if (!response) {
       timings.turns.push(turnMetrics);
       break;
     }
-    messages.push({ role: "assistant", content: assistantContent });
-    const toolCalls = parser.parse(assistantContent);
+    const toolCalls = response.tool_calls;
+    messages.push({
+      role: "assistant",
+      content: response.content,
+      ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+    });
     if (toolCalls.length === 0) {
-      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" });
+      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." });
       terminationReason = "terminated";
       timings.turns.push(turnMetrics);
       break;
     }
     yield {
       turn,
-      toolCalls: toolCalls.map((c) => ({
-        name: c.name,
-        arguments: c.arguments ?? {}
+      toolCalls: toolCalls.map((tc) => ({
+        name: tc.function.name,
+        arguments: safeParseJSON(tc.function.arguments)
       }))
     };
-    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;
+    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);
       finishMeta = { files };
       terminationReason = "completed";
       if (files.length === 0) {
-        const payload2 = textResult || "No relevant code found.";
+        const payload2 = filesStr || "No relevant code found.";
+        timings.turns.push(turnMetrics);
         timings.total_ms = Date.now() - totalStart;
         return {
           terminationReason: "completed",
@@ -1532,8 +1466,25 @@ 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;
@@ -1551,17 +1502,22 @@ async function* runWarpGrepStreaming(config) {
     repoRoot,
     finishMeta.files,
     async (p, s, e) => {
+      let resolvedPath = p;
+      if (!p.startsWith(repoRoot)) {
+        const relative = p.startsWith("/") ? p.slice(1) : p;
+        resolvedPath = import_path3.default.join(repoRoot, relative);
+      }
       try {
-        const rr = await provider.read({ path: p, start: s, end: e });
+        const rr = await provider.read({ path: resolvedPath, 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}]`];
+        fileReadErrors.push({ path: resolvedPath, error: errorMsg });
+        console.error(`[warp_grep] Failed to read file: ${resolvedPath} - ${errorMsg}`);
+        return [`[couldn't find: ${resolvedPath}]`];
       }
     }
   );
@@ -1577,6 +1533,14 @@ 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();
@@ -1756,6 +1720,35 @@ 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
@@ -1782,9 +1775,9 @@ function createCodeStorageHttpCommands(config) {
   const { baseUrl, repoId, branch } = config;
   const encodedRepoId = encodeURIComponent(repoId);
   return {
-    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")
+    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")
   };
 }