@morphllm/morphsdk 0.2.44 → 0.2.46

package/dist/client.cjs

@@ -468,15 +468,46 @@ var BrowserClient = class {
     return executeBrowserTask(input, this.config);
   }
   async createTask(input) {
+    const apiUrl = this.config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+    const debug = this.config.debug || false;
+    if (debug) {
+      console.log(`[Browser] createTask: "${input.task.slice(0, 60)}..." url=${input.url || "none"}`);
+      console.log(`[Browser] Calling async endpoint: ${apiUrl}/browser-task/async`);
+    }
+    const headers = { "Content-Type": "application/json" };
+    if (this.config.apiKey) headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    const response = await fetch(`${apiUrl}/browser-task/async`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        task: input.task,
+        url: input.url,
+        max_steps: input.max_steps ?? 10,
+        model: input.model ?? "morph-computer-use-v0",
+        viewport_width: input.viewport_width ?? 1280,
+        viewport_height: input.viewport_height ?? 720,
+        external_id: input.external_id,
+        repo_id: input.repo_id,
+        commit_id: input.commit_id,
+        record_video: input.record_video ?? false,
+        video_width: input.video_width ?? input.viewport_width ?? 1280,
+        video_height: input.video_height ?? input.viewport_height ?? 720,
+        allow_resizing: input.allow_resizing ?? false,
+        structured_output: "schema" in input ? stringifyStructuredOutput(input.schema) : void 0
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      if (debug) console.error(`[Browser] Error: ${response.status} - ${errorText}`);
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    if (debug) {
+      console.log(`[Browser] \u2705 Task created: recording_id=${result.recording_id ?? "none"} debug_url=${result.debugUrl ? "available" : "none"}`);
+    }
     if ("schema" in input) {
-      const taskInput = {
-        ...input,
-        structured_output: stringifyStructuredOutput(input.schema)
-      };
-      const result = await executeBrowserTask(taskInput, this.config);
       return wrapTaskResponseWithSchema(result, this.config, input.schema);
     } else {
-      const result = await executeBrowserTask(input, this.config);
       return wrapTaskResponse(result, this.config);
     }
   }
@@ -553,6 +584,7 @@ async function executeBrowserTask(input, config = {}) {
           record_video: input.record_video ?? false,
           video_width: input.video_width ?? input.viewport_width ?? 1280,
           video_height: input.video_height ?? input.viewport_height ?? 720,
+          allow_resizing: input.allow_resizing ?? false,
           structured_output: input.structured_output
         })
       },
@@ -746,7 +778,21 @@ function wrapTaskResponse(result, config) {
     task_id: result.task_id || "",
     liveUrl: result.task_id ? generateLiveUrl(result.task_id, config) : result.debugUrl || "",
     complete: async (pollConfig) => {
-      return pollTaskUntilComplete(result.task_id, config, pollConfig);
+      if (result.task_id) {
+        return pollTaskUntilComplete(result.task_id, config, pollConfig);
+      }
+      if (result.recording_id) {
+        const recording = await waitForRecording(
+          result.recording_id,
+          config,
+          pollConfig
+        );
+        return {
+          ...result,
+          recording_status: recording.status
+        };
+      }
+      throw new Error("Cannot poll completion: no task_id or recording_id available");
     },
     // Add Steel live session helpers - either functional or error-throwing
     getLiveUrl: result.debugUrl ? (options) => buildLiveUrl(result.debugUrl, options) : () => {
@@ -777,8 +823,22 @@ function wrapTaskResponseWithSchema(result, config, schema) {
     task_id: result.task_id || "",
     liveUrl: result.task_id ? generateLiveUrl(result.task_id, config) : result.debugUrl || "",
     complete: async (pollConfig) => {
-      const finalResult = await pollTaskUntilComplete(result.task_id, config, pollConfig);
-      return parseStructuredTaskOutput(finalResult, schema);
+      if (result.task_id) {
+        const finalResult = await pollTaskUntilComplete(result.task_id, config, pollConfig);
+        return parseStructuredTaskOutput(finalResult, schema);
+      }
+      if (result.recording_id) {
+        const recording = await waitForRecording(
+          result.recording_id,
+          config,
+          pollConfig
+        );
+        return {
+          ...parsed,
+          recording_status: recording.status
+        };
+      }
+      throw new Error("Cannot poll completion: no task_id or recording_id available");
     },
     // Add Steel live session helpers - either functional or error-throwing
     getLiveUrl: result.debugUrl ? (options) => buildLiveUrl(result.debugUrl, options) : () => {
@@ -830,10 +890,1095 @@ async function checkHealth(config = {}) {
   }
 }
 
+// tools/warp_grep/agent/config.ts
+var AGENT_CONFIG = {
+  // Give the model freedom; failsafe cap to prevent infinite loops
+  MAX_ROUNDS: 10,
+  TIMEOUT_MS: 3e4
+};
+var BUILTIN_EXCLUDES = [
+  // Version control
+  ".git",
+  ".svn",
+  ".hg",
+  ".bzr",
+  // Dependencies
+  "node_modules",
+  "bower_components",
+  ".pnpm",
+  ".yarn",
+  "vendor",
+  "packages",
+  "Pods",
+  ".bundle",
+  // Python
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  ".venv",
+  "venv",
+  ".tox",
+  ".nox",
+  ".eggs",
+  "*.egg-info",
+  // Build outputs
+  "dist",
+  "build",
+  "out",
+  "output",
+  "target",
+  "_build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".vercel",
+  ".netlify",
+  // Cache directories
+  ".cache",
+  ".parcel-cache",
+  ".turbo",
+  ".nx",
+  ".gradle",
+  // IDE/Editor
+  ".idea",
+  ".vscode",
+  ".vs",
+  // Coverage
+  "coverage",
+  ".coverage",
+  "htmlcov",
+  ".nyc_output",
+  // Temporary
+  "tmp",
+  "temp",
+  ".tmp",
+  ".temp",
+  // Lock files
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "bun.lockb",
+  "Cargo.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  // Binary/minified
+  "*.min.js",
+  "*.min.css",
+  "*.bundle.js",
+  "*.wasm",
+  "*.so",
+  "*.dll",
+  "*.pyc",
+  "*.map",
+  "*.js.map",
+  // Hidden directories catch-all
+  ".*"
+];
+var DEFAULT_EXCLUDES = (process.env.MORPH_WARP_GREP_EXCLUDE || "").split(",").map((s) => s.trim()).filter(Boolean).concat(BUILTIN_EXCLUDES);
+var DEFAULT_MODEL = "morph-warp-grep";
+
+// tools/warp_grep/agent/prompt.ts
+var SYSTEM_PROMPT = `You are a code search agent. Your task is to find all relevant code for a given query.
+
+<workflow>
+You have exactly 4 turns. The 4th turn MUST be a \`finish\` call. Each turn allows up to 8 parallel tool calls.
+
+- Turn 1: Map the territory OR dive deep (based on query specificity)
+- Turn 2-3: Refine based on findings
+- Turn 4: MUST call \`finish\` with all relevant code locations
+- You MAY call \`finish\` early if confident\u2014but never before at least 1 search turn.
+
+Remember, if the task feels easy to you, it is strongly desirable to call \`finish\` early using fewer turns, but quality over speed.
+</workflow>
+
+<tools>
+### \`analyse <path> [pattern]\`
+Directory tree or file search. Shows structure of a path, optionally filtered by regex pattern.
+- \`path\`: Required. Directory or file path (use \`.\` for repo root)
+- \`pattern\`: Optional regex to filter results
+
+Examples:
+\`\`\`
+analyse .
+analyse src/api
+analyse . ".*\\.ts$"
+analyse src "test.*"
+\`\`\`
+
+### \`read <path>[:start-end]\`
+Read file contents. Line range is 1-based, inclusive.
+- Returns numbered lines for easy reference
+- Omit range to read entire file
+
+Examples:
+\`\`\`
+read src/main.py
+read src/db/conn.py:10-50
+read package.json:1-20
+\`\`\`
+
+### \`grep '<pattern>' <path>\`
+Ripgrep search. Finds pattern matches across files.
+- \`'<pattern>'\`: Required. Regex pattern wrapped in single quotes
+- \`<path>\`: Required. Directory or file to search (use \`.\` for repo root)
+
+Examples:
+\`\`\`
+grep 'class.*Service' src/
+grep 'def authenticate' .
+grep 'import.*from' src/components/
+grep 'TODO' .
+\`\`\`
+
+### \`finish <file1:ranges> [file2:ranges ...]\`
+Submit final answer with all relevant code locations.
+- Include generous line ranges\u2014don't be stingy with context
+- Ranges are comma-separated: \`file.py:10-30,50-60\`
+- ALWAYS include import statements at the top of files (usually lines 1-20)
+- If code spans multiple files, include ALL of them
+- Small files can be returned in full
+
+Examples:
+\`\`\`
+finish src/auth.py:1-15,25-50,75-80 src/models/user.py:1-10,20-45
+finish src/index.ts:1-100
+\`\`\`
+</tools>
+
+<strategy>
+**Before your first tool call, classify the query:**
+
+| Query Type | Turn 1 Strategy | Early Finish? |
+|------------|-----------------|---------------|
+| **Specific** (function name, error string, unique identifier) | 8 parallel greps on likely paths | Often by turn 2 |
+| **Conceptual** (how does X work, where is Y handled) | analyse + 2-3 broad greps | Rarely early |
+| **Exploratory** (find all tests, list API endpoints) | analyse at multiple depths | Usually needs 3 turns |
+
+**Parallel call patterns:**
+- **Shotgun grep**: Same pattern, 8 different directories\u2014fast coverage
+- **Variant grep**: 8 pattern variations (synonyms, naming conventions)\u2014catches inconsistent codebases
+- **Funnel**: 1 analyse + 7 greps\u2014orient and search simultaneously
+- **Deep read**: 8 reads on files you already identified\u2014gather full context fast
+</strategy>
+
+<output_format>
+EVERY response MUST follow this exact format:
+
+1. First, wrap your reasoning in \`<think>...</think>\` tags containing:
+   - Query classification (specific/conceptual/exploratory)
+   - Confidence estimate (can I finish in 1-2 turns?)
+   - This turn's parallel strategy
+   - What signals would let me finish early?
+
+2. Then, output tool calls wrapped in \`<tool_call>...</tool_call>\` tags, one per line.
+
+Example:
+\`\`\`
+<think>
+This is a specific query about authentication. I'll grep for auth-related patterns.
+High confidence I can finish in 2 turns if I find the auth module.
+Strategy: Shotgun grep across likely directories.
+</think>
+<tool_call>grep 'authenticate' src/</tool_call>
+<tool_call>grep 'login' src/</tool_call>
+<tool_call>analyse src/auth</tool_call>
+\`\`\`
+
+No commentary outside \`<think>\`. No explanations after tool calls.
+</output_format>
+
+<finishing_requirements>
+When calling \`finish\`:
+- Include the import section (typically lines 1-20) of each file
+- Include all function/class definitions that are relevant
+- Include any type definitions, interfaces, or constants used
+- Better to over-include than leave the user missing context
+- If unsure about boundaries, include more rather than less
+</finishing_requirements>
+
+Begin your exploration now to find code relevant to the query.`;
+function getSystemPrompt() {
+  return SYSTEM_PROMPT;
+}
+
+// tools/warp_grep/agent/parser.ts
+var LLMResponseParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LLMResponseParseError";
+  }
+};
+var VALID_COMMANDS = ["analyse", "grep", "read", "finish"];
+function preprocessText(text) {
+  let processed = text.replace(/<think>[\s\S]*?<\/think>/gi, "");
+  const openingTagRegex = /<tool_call>|<tool>/gi;
+  const closingTagRegex = /<\/tool_call>|<\/tool>/gi;
+  const openingMatches = processed.match(openingTagRegex) || [];
+  const closingMatches = processed.match(closingTagRegex) || [];
+  if (openingMatches.length > closingMatches.length) {
+    const lastClosingMatch = /<\/tool_call>|<\/tool>/gi;
+    let lastClosingIndex = -1;
+    let match;
+    while ((match = lastClosingMatch.exec(processed)) !== null) {
+      lastClosingIndex = match.index + match[0].length;
+    }
+    if (lastClosingIndex > 0) {
+      processed = processed.slice(0, lastClosingIndex);
+    }
+  }
+  const toolCallLines = [];
+  const toolTagRegex = /<tool_call>([\s\S]*?)<\/tool_call>|<tool>([\s\S]*?)<\/tool>/gi;
+  let tagMatch;
+  while ((tagMatch = toolTagRegex.exec(processed)) !== null) {
+    const content = (tagMatch[1] || tagMatch[2] || "").trim();
+    if (content) {
+      const lines = content.split(/\r?\n/).map((l) => l.trim()).filter((l) => l);
+      toolCallLines.push(...lines);
+    }
+  }
+  const allLines = processed.split(/\r?\n/).map((l) => l.trim());
+  for (const line of allLines) {
+    if (!line) continue;
+    if (line.startsWith("<")) continue;
+    const firstWord = line.split(/\s/)[0];
+    if (VALID_COMMANDS.includes(firstWord)) {
+      if (!toolCallLines.includes(line)) {
+        toolCallLines.push(line);
+      }
+    }
+  }
+  return toolCallLines;
+}
+var LLMResponseParser = class {
+  finishSpecSplitRe = /,(?=[^,\s]+:)/;
+  parse(text) {
+    if (typeof text !== "string") {
+      throw new TypeError("Command text must be a string.");
+    }
+    const lines = preprocessText(text);
+    const commands = [];
+    let finishAccumulator = null;
+    lines.forEach((line, idx) => {
+      if (!line || line.startsWith("#")) return;
+      const ctx = { lineNumber: idx + 1, raw: line };
+      const parts = this.splitLine(line, ctx);
+      if (parts.length === 0) return;
+      const cmd = parts[0];
+      switch (cmd) {
+        case "analyse":
+          this.handleAnalyse(parts, ctx, commands);
+          break;
+        case "grep":
+          this.handleGrep(parts, ctx, commands);
+          break;
+        case "read":
+          this.handleRead(parts, ctx, commands);
+          break;
+        case "finish":
+          finishAccumulator = this.handleFinish(parts, ctx, finishAccumulator);
+          break;
+        default:
+          break;
+      }
+    });
+    if (finishAccumulator) {
+      const map = finishAccumulator;
+      const entries = [...map.entries()];
+      const filesPayload = entries.map(([path4, ranges]) => ({
+        path: path4,
+        lines: [...ranges].sort((a, b) => a[0] - b[0])
+      }));
+      commands.push({ name: "finish", arguments: { files: filesPayload } });
+    }
+    return commands;
+  }
+  splitLine(line, ctx) {
+    try {
+      const parts = [];
+      let current = "";
+      let inSingle = false;
+      for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === "'" && line[i - 1] !== "\\") {
+          inSingle = !inSingle;
+          current += ch;
+        } else if (!inSingle && /\s/.test(ch)) {
+          if (current) {
+            parts.push(current);
+            current = "";
+          }
+        } else {
+          current += ch;
+        }
+      }
+      if (current) parts.push(current);
+      return parts;
+    } catch {
+      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: Unable to parse line.`);
+    }
+  }
+  handleAnalyse(parts, ctx, commands) {
+    if (parts.length < 2) {
+      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: analyse requires <path>`);
+    }
+    const path4 = parts[1];
+    const pattern = parts[2]?.replace(/^"|"$/g, "") ?? null;
+    commands.push({ name: "analyse", arguments: { path: path4, pattern } });
+  }
+  // no glob tool in MCP
+  handleGrep(parts, ctx, commands) {
+    if (parts.length < 3) {
+      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: grep requires '<pattern>' and <path>`);
+    }
+    const pat = parts[1];
+    if (!pat.startsWith("'") || !pat.endsWith("'")) {
+      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: grep pattern must be single-quoted`);
+    }
+    commands.push({ name: "grep", arguments: { pattern: pat.slice(1, -1), path: parts[2] } });
+  }
+  handleRead(parts, ctx, commands) {
+    if (parts.length < 2) {
+      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: read requires <path> or <path>:<start-end>`);
+    }
+    const spec = parts[1];
+    const rangeIdx = spec.indexOf(":");
+    if (rangeIdx === -1) {
+      commands.push({ name: "read", arguments: { path: spec } });
+      return;
+    }
+    const path4 = spec.slice(0, rangeIdx);
+    const range = spec.slice(rangeIdx + 1);
+    const [s, e] = range.split("-").map((v) => parseInt(v, 10));
+    if (!Number.isFinite(s) || !Number.isFinite(e)) {
+      throw new LLMResponseParseError(`Line ${ctx.lineNumber}: invalid read range '${range}'`);
+    }
+    commands.push({ name: "read", arguments: { path: path4, start: s, end: e } });
+  }
+  handleFinish(parts, ctx, acc) {
+    const map = acc ?? /* @__PURE__ */ new Map();
+    const args = parts.slice(1);
+    for (const token of args) {
+      const [path4, rangesText] = token.split(":", 2);
+      if (!path4 || !rangesText) {
+        throw new LLMResponseParseError(`Line ${ctx.lineNumber}: invalid finish token '${token}'`);
+      }
+      const rangeSpecs = rangesText.split(",").filter(Boolean);
+      for (const spec of rangeSpecs) {
+        const [s, e] = spec.split("-").map((v) => parseInt(v, 10));
+        if (!Number.isFinite(s) || !Number.isFinite(e) || e < s) {
+          throw new LLMResponseParseError(`Line ${ctx.lineNumber}: invalid range '${spec}'`);
+        }
+        const arr = map.get(path4) ?? [];
+        arr.push([s, e]);
+        map.set(path4, arr);
+      }
+    }
+    return map;
+  }
+};
+
+// tools/warp_grep/tools/read.ts
+async function toolRead(provider, args) {
+  const res = await provider.read({ path: args.path, start: args.start, end: args.end });
+  return res.lines.join("\n");
+}
+
+// tools/warp_grep/tools/analyse.ts
+async function toolAnalyse(provider, args) {
+  const list = await provider.analyse({
+    path: args.path,
+    pattern: args.pattern ?? null,
+    maxResults: args.maxResults ?? 100,
+    maxDepth: args.maxDepth ?? 2
+  });
+  if (!list.length) return "empty";
+  return list.map((e) => `${"  ".repeat(e.depth)}- ${e.type === "dir" ? "[D]" : "[F]"} ${e.name}`).join("\n");
+}
+
+// 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);
+    const safeArgs = args ?? {};
+    if (!payload && !isError) {
+      return "";
+    }
+    switch (name) {
+      case "read":
+        return this.formatRead(safeArgs, payload, isError);
+      case "analyse":
+        return this.formatAnalyse(safeArgs, payload, isError);
+      case "grep":
+        return this.formatGrep(safeArgs, payload, isError);
+      default:
+        return payload ? `<tool_output>
+${payload}
+</tool_output>` : "";
+    }
+  }
+  formatRead(args, payload, isError) {
+    if (isError) {
+      return payload;
+    }
+    const path4 = this.asString(args.path) || "...";
+    return `<file path="${path4}">
+${payload}
+</file>`;
+  }
+  formatAnalyse(args, payload, isError) {
+    const path4 = this.asString(args.path) || ".";
+    if (isError) {
+      return `<analyse_results path="${path4}" status="error">
+${payload}
+</analyse_results>`;
+    }
+    return `<analyse_results path="${path4}">
+${payload}
+</analyse_results>`;
+  }
+  formatGrep(args, payload, isError) {
+    const pattern = this.asString(args.pattern);
+    const path4 = this.asString(args.path);
+    const attributes = [];
+    if (pattern !== void 0) {
+      attributes.push(`pattern="${pattern}"`);
+    }
+    if (path4 !== void 0) {
+      attributes.push(`path="${path4}"`);
+    }
+    if (isError) {
+      attributes.push('status="error"');
+    }
+    const attrText = attributes.length ? ` ${attributes.join(" ")}` : "";
+    return `<grep_output${attrText}>
+${payload}
+</grep_output>`;
+  }
+  asString(value) {
+    if (value === null || value === void 0) {
+      return void 0;
+    }
+    return String(value);
+  }
+};
+var sharedFormatter = new ToolOutputFormatter();
+function formatAgentToolOutput(toolName, args, output, options = {}) {
+  return sharedFormatter.format(toolName, args, output, options);
+}
+
+// tools/warp_grep/agent/grep_helpers.ts
+var GrepState = class {
+  seenLines = /* @__PURE__ */ new Set();
+  isNew(path4, lineNumber) {
+    const key = this.makeKey(path4, lineNumber);
+    return !this.seenLines.has(key);
+  }
+  add(path4, lineNumber) {
+    this.seenLines.add(this.makeKey(path4, lineNumber));
+  }
+  makeKey(path4, lineNumber) {
+    return `${path4}:${lineNumber}`;
+  }
+};
+var MAX_GREP_OUTPUT_CHARS_PER_TURN = 6e4;
+function extractMatchFields(payload) {
+  const text = payload.replace(/\r?\n$/, "");
+  if (!text || text.startsWith("[error]")) {
+    return null;
+  }
+  const firstSep = text.indexOf(":");
+  if (firstSep === -1) {
+    return null;
+  }
+  let filePath = text.slice(0, firstSep).trim();
+  if (!filePath) {
+    return null;
+  }
+  if (filePath.startsWith("./") || filePath.startsWith(".\\")) {
+    filePath = filePath.slice(2);
+  }
+  const remainder = text.slice(firstSep + 1);
+  const secondSep = remainder.indexOf(":");
+  if (secondSep === -1) {
+    return null;
+  }
+  const linePart = remainder.slice(0, secondSep);
+  const lineNumber = Number.parseInt(linePart, 10);
+  if (!Number.isInteger(lineNumber) || lineNumber <= 0) {
+    return null;
+  }
+  let contentSegment = remainder.slice(secondSep + 1);
+  const columnSep = contentSegment.indexOf(":");
+  if (columnSep !== -1 && /^\d+$/.test(contentSegment.slice(0, columnSep))) {
+    contentSegment = contentSegment.slice(columnSep + 1);
+  }
+  const content = contentSegment.trim();
+  if (!content) {
+    return null;
+  }
+  return { path: filePath, lineNumber, content };
+}
+function parseAndFilterGrepOutput(rawOutput, state) {
+  const matches = [];
+  if (typeof rawOutput !== "string" || !rawOutput.trim()) {
+    return matches;
+  }
+  for (const line of rawOutput.split(/\r?\n/)) {
+    const fields = extractMatchFields(line);
+    if (!fields) {
+      continue;
+    }
+    if (state.isNew(fields.path, fields.lineNumber)) {
+      matches.push(fields);
+      state.add(fields.path, fields.lineNumber);
+    }
+  }
+  return matches;
+}
+function truncateOutput(payload, maxChars) {
+  if (payload.length <= maxChars) {
+    return payload;
+  }
+  const note = "... (output truncated)";
+  const available = maxChars - note.length - 1;
+  if (available <= 0) {
+    return note;
+  }
+  if (payload.length <= available) {
+    return `${payload.slice(0, available).replace(/\n$/, "")}
+${note}`;
+  }
+  const core = payload.slice(0, Math.max(0, available - 1));
+  const trimmed = core.replace(/\n$/, "").replace(/\s+$/, "");
+  const snippet = trimmed ? `${trimmed}\u2026` : "\u2026";
+  return `${snippet}
+${note}`;
+}
+function formatTurnGrepOutput(matches, maxChars = MAX_GREP_OUTPUT_CHARS_PER_TURN) {
+  if (!matches || matches.length === 0) {
+    return "No new matches found.";
+  }
+  const matchesByFile = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    if (!matchesByFile.has(match.path)) {
+      matchesByFile.set(match.path, []);
+    }
+    matchesByFile.get(match.path).push(match);
+  }
+  const lines = [];
+  const sortedPaths = Array.from(matchesByFile.keys()).sort();
+  sortedPaths.forEach((filePath, index) => {
+    if (index > 0) {
+      lines.push("");
+    }
+    lines.push(filePath);
+    const sortedMatches = matchesByFile.get(filePath).slice().sort((a, b) => a.lineNumber - b.lineNumber);
+    for (const match of sortedMatches) {
+      lines.push(`${match.lineNumber}:${match.content}`);
+    }
+  });
+  return truncateOutput(lines.join("\n"), maxChars);
+}
+
+// tools/warp_grep/tools/finish.ts
+async function readFinishFiles(repoRoot, files, reader) {
+  const out = [];
+  for (const f of files) {
+    const ranges = mergeRanges(f.lines);
+    const chunks = [];
+    for (const [s, e] of ranges) {
+      const lines = await reader(f.path, s, e);
+      chunks.push(lines.join("\n"));
+    }
+    out.push({ path: f.path, ranges, content: chunks.join("\n") });
+  }
+  return out;
+}
+function mergeRanges(ranges) {
+  if (!ranges.length) return [];
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  let [cs, ce] = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    const [s, e] = sorted[i];
+    if (s <= ce + 1) {
+      ce = Math.max(ce, e);
+    } else {
+      merged.push([cs, ce]);
+      cs = s;
+      ce = e;
+    }
+  }
+  merged.push([cs, ce]);
+  return merged;
+}
+
+// tools/warp_grep/agent/runner.ts
+var import_path2 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var parser = new LLMResponseParser();
+async function buildInitialState(repoRoot, query) {
+  try {
+    const entries = await import_promises2.default.readdir(repoRoot, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory()).map((d) => d.name).slice(0, 50);
+    const files = entries.filter((e) => e.isFile()).map((f) => f.name).slice(0, 50);
+    const parts = [
+      `<repo_root>${repoRoot}</repo_root>`,
+      `<top_dirs>${dirs.join(", ")}</top_dirs>`,
+      `<top_files>${files.join(", ")}</top_files>`
+    ];
+    return parts.join("\n");
+  } catch {
+    return `<repo_root>${repoRoot}</repo_root>`;
+  }
+}
+async function callModel(messages, model, apiKey) {
+  const api = "https://api.morphllm.com/v1/chat/completions";
+  const fetchPromise = fetchWithRetry(
+    api,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey || process.env.MORPH_API_KEY || ""}`
+      },
+      body: JSON.stringify({
+        model,
+        temperature: 0,
+        max_tokens: 1024,
+        messages
+      })
+    },
+    {}
+  );
+  const resp = await withTimeout(fetchPromise, AGENT_CONFIG.TIMEOUT_MS, "morph-warp-grep request timed out");
+  if (!resp.ok) {
+    const t = await resp.text();
+    throw new Error(`morph-warp-grep error ${resp.status}: ${t}`);
+  }
+  const data = await resp.json();
+  const content = data?.choices?.[0]?.message?.content;
+  if (!content || typeof content !== "string") {
+    throw new Error("Invalid response from model");
+  }
+  return content;
+}
+async function runWarpGrep(config) {
+  const repoRoot = import_path2.default.resolve(config.repoRoot || process.cwd());
+  const messages = [];
+  const systemMessage = { role: "system", content: getSystemPrompt() };
+  messages.push(systemMessage);
+  const queryContent = `<query>${config.query}</query>`;
+  messages.push({ role: "user", content: queryContent });
+  const initialState = await buildInitialState(repoRoot, config.query);
+  messages.push({ role: "user", content: initialState });
+  const maxRounds = AGENT_CONFIG.MAX_ROUNDS;
+  const model = config.model || DEFAULT_MODEL;
+  const provider = config.provider;
+  const errors = [];
+  const grepState = new GrepState();
+  let finishMeta;
+  let terminationReason = "terminated";
+  for (let round = 1; round <= maxRounds; round += 1) {
+    const assistantContent = await callModel(messages, model, config.apiKey).catch((e) => {
+      errors.push({ message: e instanceof Error ? e.message : String(e) });
+      return "";
+    });
+    if (!assistantContent) break;
+    messages.push({ role: "assistant", content: assistantContent });
+    let toolCalls = [];
+    try {
+      toolCalls = parser.parse(assistantContent);
+    } catch (e) {
+      errors.push({ message: e instanceof Error ? e.message : String(e) });
+      terminationReason = "terminated";
+      break;
+    }
+    if (toolCalls.length === 0) {
+      errors.push({ message: "No tool calls produced by the model." });
+      terminationReason = "terminated";
+      break;
+    }
+    const finishCalls = toolCalls.filter((c) => c.name === "finish");
+    const grepCalls = toolCalls.filter((c) => c.name === "grep");
+    const analyseCalls = toolCalls.filter((c) => c.name === "analyse");
+    const readCalls = toolCalls.filter((c) => c.name === "read");
+    const formatted = [];
+    const otherPromises = [];
+    for (const c of analyseCalls) {
+      const args = c.arguments ?? {};
+      otherPromises.push(
+        toolAnalyse(provider, args).then(
+          (p) => formatAgentToolOutput("analyse", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("analyse", args, String(err), { isError: true })
+        )
+      );
+    }
+    for (const c of readCalls) {
+      const args = c.arguments ?? {};
+      otherPromises.push(
+        toolRead(provider, args).then(
+          (p) => formatAgentToolOutput("read", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("read", args, String(err), { isError: true })
+        )
+      );
+    }
+    const otherResults = await Promise.all(otherPromises);
+    formatted.push(...otherResults);
+    for (const c of grepCalls) {
+      const args = c.arguments ?? {};
+      try {
+        const grepRes = await provider.grep({ pattern: args.pattern, path: args.path });
+        const rawOutput = Array.isArray(grepRes.lines) ? grepRes.lines.join("\n") : "";
+        const newMatches = parseAndFilterGrepOutput(rawOutput, grepState);
+        let formattedPayload = formatTurnGrepOutput(newMatches);
+        if (formattedPayload === "No new matches found.") {
+          formattedPayload = "no new matches";
+        }
+        formatted.push(formatAgentToolOutput("grep", args, formattedPayload, { isError: false }));
+      } catch (err) {
+        formatted.push(formatAgentToolOutput("grep", args, String(err), { isError: true }));
+      }
+    }
+    if (formatted.length > 0) {
+      const turnsUsed = round;
+      const turnsRemaining = 4 - turnsUsed;
+      let turnMessage;
+      if (turnsRemaining === 0) {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] This is your LAST turn. You MUST call the finish tool now.`;
+      } else if (turnsRemaining === 1) {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] You have 1 turn remaining. Next turn you MUST call the finish tool.`;
+      } else {
+        turnMessage = `
+
+[Turn ${turnsUsed}/4] You have ${turnsRemaining} turns remaining.`;
+      }
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage });
+    }
+    if (finishCalls.length) {
+      const fc = finishCalls[0];
+      const files = fc.arguments?.files ?? [];
+      finishMeta = { files };
+      terminationReason = "completed";
+      break;
+    }
+  }
+  if (terminationReason !== "completed" || !finishMeta) {
+    return { terminationReason, messages, errors };
+  }
+  const parts = ["Relevant context found:"];
+  for (const f of finishMeta.files) {
+    const ranges = f.lines.map(([s, e]) => `${s}-${e}`).join(", ");
+    parts.push(`- ${f.path}: ${ranges}`);
+  }
+  const payload = parts.join("\n");
+  const resolved = await readFinishFiles(
+    repoRoot,
+    finishMeta.files,
+    async (p, s, e) => {
+      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;
+      });
+    }
+  );
+  return {
+    terminationReason: "completed",
+    messages,
+    finish: { payload, metadata: finishMeta, resolved }
+  };
+}
+
+// tools/warp_grep/providers/local.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_path4 = __toESM(require("path"), 1);
+
+// tools/warp_grep/utils/ripgrep.ts
+var import_child_process = require("child_process");
+function runRipgrep(args, opts) {
+  return new Promise((resolve2) => {
+    const child = (0, import_child_process.spawn)("rg", args, {
+      cwd: opts?.cwd,
+      env: { ...process.env, ...opts?.env || {} },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", (code) => {
+      resolve2({ stdout, stderr, exitCode: typeof code === "number" ? code : -1 });
+    });
+    child.on("error", () => {
+      resolve2({ stdout: "", stderr: "Failed to spawn ripgrep (rg). Ensure it is installed.", exitCode: -1 });
+    });
+  });
+}
+
+// tools/warp_grep/utils/paths.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+function resolveUnderRepo(repoRoot, 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_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_path3.default.relative(import_path3.default.resolve(repoRoot), import_path3.default.resolve(absPath));
+}
+function isSymlink(p) {
+  try {
+    const st = import_fs.default.lstatSync(p);
+    return st.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function isTextualFile(filePath, maxBytes = 2e6) {
+  try {
+    const st = import_fs.default.statSync(filePath);
+    if (!st.isFile()) return false;
+    if (st.size > maxBytes) return false;
+    const fd = import_fs.default.openSync(filePath, "r");
+    const buf = Buffer.alloc(512);
+    const read = import_fs.default.readSync(fd, buf, 0, buf.length, 0);
+    import_fs.default.closeSync(fd);
+    for (let i = 0; i < read; i++) {
+      const c = buf[i];
+      if (c === 0) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// tools/warp_grep/utils/files.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+async function readAllLines(filePath) {
+  const content = await import_promises3.default.readFile(filePath, "utf8");
+  return content.split(/\r?\n/);
+}
+
+// tools/warp_grep/providers/local.ts
+var LocalRipgrepProvider = class {
+  constructor(repoRoot, excludes = DEFAULT_EXCLUDES) {
+    this.repoRoot = repoRoot;
+    this.excludes = excludes;
+  }
+  async grep(params) {
+    const abs = resolveUnderRepo(this.repoRoot, params.path);
+    const stat = await import_promises4.default.stat(abs).catch(() => null);
+    if (!stat) return { lines: [] };
+    const targetArg = abs === import_path4.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
+    const args = [
+      "--no-config",
+      "--no-heading",
+      "--with-filename",
+      "--line-number",
+      "--color=never",
+      "--trim",
+      "--max-columns=400",
+      ...this.excludes.flatMap((e) => ["-g", `!${e}`]),
+      params.pattern,
+      targetArg || "."
+    ];
+    const res = await runRipgrep(args, { cwd: this.repoRoot });
+    if (res.exitCode === -1) {
+      throw new Error(res.stderr || "ripgrep (rg) execution failed.");
+    }
+    if (res.exitCode !== 0 && res.exitCode !== 1) {
+      throw new Error(res.stderr || `ripgrep failed with code ${res.exitCode}`);
+    }
+    const lines = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
+    return { lines };
+  }
+  async glob(params) {
+    const abs = resolveUnderRepo(this.repoRoot, params.path);
+    const targetArg = abs === import_path4.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
+    const args = [
+      "--no-config",
+      "--files",
+      "-g",
+      params.pattern,
+      ...this.excludes.flatMap((e) => ["-g", `!${e}`]),
+      targetArg || "."
+    ];
+    const res = await runRipgrep(args, { cwd: this.repoRoot });
+    if (res.exitCode === -1) {
+      throw new Error(res.stderr || "ripgrep (rg) execution failed.");
+    }
+    const files = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
+    return { files };
+  }
+  async read(params) {
+    const abs = resolveUnderRepo(this.repoRoot, params.path);
+    const stat = await import_promises4.default.stat(abs).catch(() => null);
+    if (!stat || !stat.isFile()) {
+      throw new Error(`Path is not a file: ${params.path}`);
+    }
+    if (isSymlink(abs)) {
+      throw new Error(`Refusing to read symlink: ${params.path}`);
+    }
+    if (!isTextualFile(abs)) {
+      throw new Error(`Non-text or too-large file: ${params.path}`);
+    }
+    const lines = await readAllLines(abs);
+    const total = lines.length;
+    const s = params.start ?? 1;
+    const e = Math.min(params.end ?? total, total);
+    if (s > total && total > 0) {
+      throw new Error(`start ${s} exceeds file length (${total})`);
+    }
+    const out = [];
+    for (let i = s; i <= e; i += 1) {
+      const content = lines[i - 1] ?? "";
+      out.push(`${i}|${content}`);
+    }
+    return { lines: out };
+  }
+  async analyse(params) {
+    const abs = resolveUnderRepo(this.repoRoot, params.path);
+    const stat = await import_promises4.default.stat(abs).catch(() => null);
+    if (!stat || !stat.isDirectory()) {
+      return [];
+    }
+    const maxResults = params.maxResults ?? 100;
+    const maxDepth = params.maxDepth ?? 2;
+    const regex = params.pattern ? new RegExp(params.pattern) : null;
+    const results = [];
+    async function walk(dir, depth) {
+      if (depth > maxDepth || results.length >= maxResults) return;
+      const entries = await import_promises4.default.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const full = import_path4.default.join(dir, entry.name);
+        const rel = toRepoRelative(abs, full).replace(/^[.][/\\]?/, "");
+        if (DEFAULT_EXCLUDES.some((ex) => rel.split(import_path4.default.sep).includes(ex))) continue;
+        if (regex && !regex.test(entry.name)) continue;
+        if (results.length >= maxResults) break;
+        results.push({
+          name: entry.name,
+          path: toRepoRelative(import_path4.default.resolve(""), full),
+          // relative display
+          type: entry.isDirectory() ? "dir" : "file",
+          depth
+        });
+        if (entry.isDirectory()) {
+          await walk(full, depth + 1);
+        }
+      }
+    }
+    await walk(abs, 0);
+    return results;
+  }
+};
+
+// tools/warp_grep/core.ts
+var WarpGrepClient = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      apiKey: config.apiKey,
+      debug: config.debug,
+      timeout: config.timeout,
+      retryConfig: config.retryConfig
+    };
+  }
+  /**
+   * Execute a code search query
+   * 
+   * @param input - Search parameters including query, repoRoot, and optional provider
+   * @returns Search results with relevant code contexts
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.execute({
+   *   query: 'Find authentication middleware',
+   *   repoRoot: '.'
+   * });
+   * 
+   * if (result.success) {
+   *   for (const ctx of result.contexts) {
+   *     console.log(`File: ${ctx.file}`);
+   *     console.log(ctx.content);
+   *   }
+   * }
+   * ```
+   */
+  async execute(input) {
+    const provider = input.provider ?? new LocalRipgrepProvider(input.repoRoot, input.excludes);
+    const result = await runWarpGrep({
+      query: input.query,
+      repoRoot: input.repoRoot,
+      provider,
+      excludes: input.excludes,
+      includes: input.includes,
+      debug: input.debug ?? this.config.debug ?? false,
+      apiKey: this.config.apiKey
+    });
+    const finish = result.finish;
+    if (result.terminationReason !== "completed" || !finish?.metadata) {
+      return {
+        success: false,
+        error: "Search did not complete"
+      };
+    }
+    const contexts = (finish.resolved ?? []).map((r) => ({
+      file: r.path,
+      content: r.content
+    }));
+    return {
+      success: true,
+      contexts,
+      summary: finish.payload
+    };
+  }
+};
+function formatResult(result) {
+  if (!result.success) {
+    return `Search failed: ${result.error}`;
+  }
+  if (!result.contexts || result.contexts.length === 0) {
+    return "No relevant code found. Try rephrasing your query.";
+  }
+  const lines = [];
+  lines.push(`Found ${result.contexts.length} relevant code sections:
+`);
+  result.contexts.forEach((ctx, i) => {
+    lines.push(`${i + 1}. ${ctx.file}`);
+    lines.push("```");
+    lines.push(ctx.content);
+    lines.push("```");
+    lines.push("");
+  });
+  if (result.summary) {
+    lines.push(`Summary: ${result.summary}`);
+  }
+  return lines.join("\n");
+}
+
 // git/client.ts
 var import_isomorphic_git = __toESM(require("isomorphic-git"), 1);
 var import_node = __toESM(require("isomorphic-git/http/node"), 1);
-var import_fs = __toESM(require("fs"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
 var DEFAULT_PROXY_URL = "https://repos.morphllm.com";
 var MorphGit = class {
   apiKey;
@@ -890,12 +2035,12 @@ var MorphGit = class {
       throw new Error(`Failed to create repository: ${error}`);
     }
     await import_isomorphic_git.default.init({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       defaultBranch
     });
     await import_isomorphic_git.default.addRemote({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       remote: "origin",
       url: `${this.proxyUrl}/v1/repos/${repoId}`
@@ -916,7 +2061,7 @@ var MorphGit = class {
   async clone(options) {
     const { repoId, dir, branch = "main", depth, singleBranch = true } = options;
     await import_isomorphic_git.default.clone({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       http: import_node.default,
       dir,
       url: `${this.proxyUrl}/v1/repos/${repoId}`,
@@ -933,42 +2078,65 @@ var MorphGit = class {
    * ```ts
    * await morphGit.push({ 
    *   dir: './my-project',
-   *   branch: 'main' // Required: explicit branch name
+   *   branch: 'main', // Required: explicit branch name
+   *   index: true     // Optional: generate embeddings (default: true)
    * });
    * ```
    */
   async push(options) {
-    const { dir, remote = "origin", branch, waitForEmbeddings } = options;
+    const { dir, remote = "origin", branch, waitForEmbeddings, index = true } = options;
     if (!branch) {
       throw new Error(
         'branch is required for push operations. Specify the branch explicitly: { dir: "./my-project", branch: "main" }'
       );
     }
-    let commitHash;
+    const commitHash = await import_isomorphic_git.default.resolveRef({ fs: import_fs2.default, dir, ref: "HEAD" });
     let repoId;
-    if (waitForEmbeddings) {
-      commitHash = await import_isomorphic_git.default.resolveRef({ fs: import_fs.default, dir, ref: "HEAD" });
-      const remotes = await import_isomorphic_git.default.listRemotes({ fs: import_fs.default, dir });
-      const originRemote = remotes.find((r) => r.remote === remote);
-      if (originRemote) {
-        const match = originRemote.url.match(/\/repos\/([^\/]+)$/);
-        if (match) {
-          repoId = match[1];
-        }
+    const remotes = await import_isomorphic_git.default.listRemotes({ fs: import_fs2.default, dir });
+    const originRemote = remotes.find((r) => r.remote === remote);
+    if (originRemote) {
+      const match = originRemote.url.match(/\/repos\/([^\/]+)$/);
+      if (match) {
+        repoId = match[1];
       }
     }
     await import_isomorphic_git.default.push({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       http: import_node.default,
       dir,
       remote,
       ref: branch,
       onAuth: this.getAuthCallback()
     });
-    if (waitForEmbeddings && repoId && commitHash) {
+    if (repoId && commitHash) {
+      await this.configureCommit({ repoId, commitHash, branch, index });
+    }
+    if (waitForEmbeddings && repoId && commitHash && index) {
       await this.waitForEmbeddings({ repoId, commitHash });
     }
   }
+  /**
+   * Configure commit settings on the backend after push.
+   * Sets the index flag to control embedding generation.
+   * @private
+   */
+  async configureCommit(options) {
+    const { repoId, commitHash, branch, index } = options;
+    const response = await fetch(
+      `${this.proxyUrl}/v1/repos/${repoId}/commits/${commitHash}/config`,
+      {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ index, branch })
+      }
+    );
+    if (!response.ok) {
+      console.warn(`Failed to configure commit: ${response.status}`);
+    }
+  }
   /**
    * Pull changes from remote repository
    * 
@@ -988,7 +2156,7 @@ var MorphGit = class {
       );
     }
     await import_isomorphic_git.default.pull({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       http: import_node.default,
       dir,
       remote,
@@ -1057,7 +2225,7 @@ var MorphGit = class {
   async add(options) {
     const { dir, filepath } = options;
     await import_isomorphic_git.default.add({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       filepath
     });
@@ -1076,7 +2244,7 @@ var MorphGit = class {
   async remove(options) {
     const { dir, filepath } = options;
     await import_isomorphic_git.default.remove({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       filepath
     });
@@ -1093,6 +2261,7 @@ var MorphGit = class {
    *     name: 'AI Agent',
    *     email: 'ai@example.com'
    *   },
+   *   metadata: { issueId: 'PROJ-123', source: 'agent' },
    *   chatHistory: [
    *     { role: 'user', content: 'Please add a new feature' },
    *     { role: 'assistant', content: 'I will add that feature' }
@@ -1102,28 +2271,30 @@ var MorphGit = class {
    * ```
    */
   async commit(options) {
-    const { dir, message, author, chatHistory, recordingId } = options;
+    const { dir, message, author, metadata, chatHistory, recordingId } = options;
     const commitAuthor = author || {
       name: "Morph SDK",
       email: "sdk@morphllm.com"
     };
     const sha = await import_isomorphic_git.default.commit({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       message,
       author: commitAuthor
     });
-    if (chatHistory || recordingId) {
-      const metadata = {
+    if (metadata || chatHistory || recordingId) {
+      const notes = {
+        metadata,
         chatHistory,
-        recordingId
+        recordingId,
+        _version: 1
       };
       await import_isomorphic_git.default.addNote({
-        fs: import_fs.default,
+        fs: import_fs2.default,
         dir,
         ref: "refs/notes/morph-metadata",
         oid: sha,
-        note: JSON.stringify(metadata, null, 2),
+        note: JSON.stringify(notes, null, 2),
         author: commitAuthor
       });
     }
@@ -1147,7 +2318,7 @@ var MorphGit = class {
       throw new Error("filepath is required for status check");
     }
     const status = await import_isomorphic_git.default.status({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       filepath
     });
@@ -1167,7 +2338,7 @@ var MorphGit = class {
   async log(options) {
     const { dir, depth, ref } = options;
     const commits = await import_isomorphic_git.default.log({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       depth,
       ref
@@ -1188,7 +2359,7 @@ var MorphGit = class {
   async checkout(options) {
     const { dir, ref } = options;
     await import_isomorphic_git.default.checkout({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       ref
     });
@@ -1208,7 +2379,7 @@ var MorphGit = class {
   async branch(options) {
     const { dir, name, checkout = false } = options;
     await import_isomorphic_git.default.branch({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       ref: name,
       checkout
@@ -1227,7 +2398,7 @@ var MorphGit = class {
   async listBranches(options) {
     const { dir } = options;
     const branches = await import_isomorphic_git.default.listBranches({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir
     });
     return branches;
@@ -1245,7 +2416,7 @@ var MorphGit = class {
   async currentBranch(options) {
     const { dir } = options;
     const branch = await import_isomorphic_git.default.currentBranch({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir
     });
     return branch || void 0;
@@ -1263,7 +2434,7 @@ var MorphGit = class {
   async statusMatrix(options) {
     const { dir } = options;
     const matrix = await import_isomorphic_git.default.statusMatrix({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir
     });
     return matrix.map(([filepath, HEADStatus, workdirStatus, stageStatus]) => {
@@ -1305,38 +2476,39 @@ var MorphGit = class {
   async resolveRef(options) {
     const { dir, ref } = options;
     const oid = await import_isomorphic_git.default.resolveRef({
-      fs: import_fs.default,
+      fs: import_fs2.default,
       dir,
       ref
     });
     return oid;
   }
   /**
-   * Get metadata (chat history, recording ID) attached to a commit
+   * Get notes (metadata, chat history, recording ID) attached to a commit
    * 
    * @example
    * ```ts
-   * const metadata = await morphGit.getCommitMetadata({
+   * const notes = await morphGit.getCommitMetadata({
    *   dir: './my-project',
    *   commitSha: 'abc123...'
    * });
    * 
-   * if (metadata) {
-   *   console.log('Chat history:', metadata.chatHistory);
-   *   console.log('Recording ID:', metadata.recordingId);
+   * if (notes) {
+   *   console.log('Metadata:', notes.metadata);
+   *   console.log('Chat history:', notes.chatHistory);
+   *   console.log('Recording ID:', notes.recordingId);
    * }
    * ```
    */
   async getCommitMetadata(options) {
     try {
       const note = await import_isomorphic_git.default.readNote({
-        fs: import_fs.default,
+        fs: import_fs2.default,
         dir: options.dir,
         ref: "refs/notes/morph-metadata",
         oid: options.commitSha
       });
-      const metadata = JSON.parse(new TextDecoder().decode(note));
-      return metadata;
+      const notes = JSON.parse(new TextDecoder().decode(note));
+      return notes;
     } catch (err) {
       return null;
     }
@@ -1547,6 +2719,718 @@ var RawRouter = class extends BaseRouter {
   }
 };
 
+// tools/warp_grep/prompts.ts
+var WARP_GREP_DESCRIPTION = "A fast and accurate tool that can search for all relevant context in a codebase. You must use this tool to save time and avoid context pollution.";
+
+// tools/warp_grep/openai.ts
+var TOOL_PARAMETERS = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Free-form repository question" }
+  },
+  required: ["query"]
+};
+async function execute(input, config) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const result = await runWarpGrep({
+    query: parsed.query,
+    repoRoot: config.repoRoot,
+    provider,
+    excludes: config.excludes,
+    includes: config.includes,
+    debug: config.debug ?? false,
+    apiKey: config.apiKey
+  });
+  const finish = result.finish;
+  if (result.terminationReason !== "completed" || !finish?.metadata) {
+    return { success: false, error: "Search did not complete" };
+  }
+  const contexts = (finish.resolved ?? []).map((r) => ({
+    file: r.path,
+    content: r.content
+  }));
+  return { success: true, contexts, summary: finish.payload };
+}
+function createMorphWarpGrepTool(config) {
+  const tool4 = {
+    type: "function",
+    function: {
+      name: "morph-warp-grep",
+      description: config.description ?? WARP_GREP_DESCRIPTION,
+      parameters: TOOL_PARAMETERS
+    }
+  };
+  return Object.assign(tool4, {
+    execute: async (input) => {
+      return execute(input, config);
+    },
+    formatResult: (result) => {
+      return formatResult(result);
+    },
+    getSystemPrompt: () => {
+      return getSystemPrompt();
+    }
+  });
+}
+
+// tools/codebase_search/prompts.ts
+var CODEBASE_SEARCH_DESCRIPTION = `Semantic search that finds code by meaning, not exact text.
+
+Use this to explore unfamiliar codebases or ask "how/where/what" questions:
+- "How does X work?" - Find implementation details
+- "Where is Y handled?" - Locate specific functionality
+- "What happens when Z?" - Understand flow
+
+The tool uses two-stage retrieval (embedding similarity + reranking) to find the most semantically relevant code chunks.
+
+Returns code chunks with file paths, line ranges, and full content ranked by relevance.`;
+var CODEBASE_SEARCH_SYSTEM_PROMPT = `You have access to the codebase_search tool that performs semantic code search.
+
+When searching:
+- Use natural language queries describing what you're looking for
+- Be specific about functionality, not variable names
+- Use target_directories to narrow search if you know the area
+- Results are ranked by relevance (rerank score is most important)
+
+The tool returns:
+- File paths with symbol names (e.g. "src/auth.ts::AuthService@L1-L17")
+- Line ranges for precise navigation
+- Full code content for each match
+- Dual relevance scores: embedding similarity + rerank score
+
+Use results to understand code or answer questions. The content is provided in full - avoid re-reading unless you need more context.`;
+
+// tools/codebase_search/openai.ts
+function createCodebaseSearchTool(config) {
+  const toolDefinition = {
+    type: "function",
+    function: {
+      name: "codebase_search",
+      description: CODEBASE_SEARCH_DESCRIPTION,
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'A complete question about what you want to understand. Ask as if talking to a colleague: "How does X work?", "What happens when Y?", "Where is Z handled?"'
+          },
+          target_directories: {
+            type: "array",
+            items: { type: "string" },
+            description: "Prefix directory paths to limit search scope (single directory only, no glob patterns). Use [] to search entire repo."
+          },
+          explanation: {
+            type: "string",
+            description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal."
+          },
+          limit: {
+            type: "number",
+            description: "Maximum results to return (default: 10)"
+          }
+        },
+        required: ["query", "target_directories", "explanation"]
+      }
+    }
+  };
+  return Object.assign(toolDefinition, {
+    execute: async (input) => {
+      const parsedInput = typeof input === "string" ? JSON.parse(input) : input;
+      return executeCodebaseSearch(parsedInput, config);
+    },
+    formatResult: (result) => {
+      return formatResult2(result);
+    },
+    getSystemPrompt: () => {
+      return CODEBASE_SEARCH_SYSTEM_PROMPT;
+    }
+  });
+}
+function formatResult2(result) {
+  if (!result.success) {
+    return `Search failed: ${result.error}`;
+  }
+  if (result.results.length === 0) {
+    return "No matching code found. Try rephrasing your query or removing directory filters.";
+  }
+  const lines = [];
+  lines.push(`Found ${result.results.length} relevant code sections (${result.stats.searchTimeMs}ms):
+`);
+  result.results.forEach((r, i) => {
+    const relevance = (r.rerankScore * 100).toFixed(1);
+    lines.push(`${i + 1}. ${r.filepath} (${relevance}% relevant)`);
+    lines.push(`   Symbol: ${r.symbolPath}`);
+    lines.push(`   Language: ${r.language}`);
+    lines.push(`   Lines: ${r.startLine}-${r.endLine}`);
+    lines.push(`   Code:`);
+    const codeLines = r.content.split("\n");
+    codeLines.slice(0, Math.min(codeLines.length, 20)).forEach((line) => {
+      lines.push(`     ${line}`);
+    });
+    if (codeLines.length > 20) {
+      lines.push(`     ... (${codeLines.length - 20} more lines)`);
+    }
+    lines.push("");
+  });
+  return lines.join("\n");
+}
+
+// tools/fastapply/prompts.ts
+var EDIT_FILE_TOOL_DESCRIPTION = `Use this tool to make an edit to an existing file.
+
+This will be read by a less intelligent model, which will quickly apply the edit. You should make it clear what the edit is, while also minimizing the unchanged code you write.
+
+When writing the edit, you should specify each edit in sequence, with the special comment // ... existing code ... to represent unchanged code in between edited lines.
+
+For example:
+
+// ... existing code ...
+FIRST_EDIT
+// ... existing code ...
+SECOND_EDIT
+// ... existing code ...
+THIRD_EDIT
+// ... existing code ...
+
+You should still bias towards repeating as few lines of the original file as possible to convey the change.
+But, each edit should contain minimally sufficient context of unchanged lines around the code you're editing to resolve ambiguity.
+
+DO NOT omit spans of pre-existing code (or comments) without using the // ... existing code ... comment to indicate its absence. If you omit the existing code comment, the model may inadvertently delete these lines.
+
+If you plan on deleting a section, you must provide context before and after to delete it.
+
+Make sure it is clear what the edit should be, and where it should be applied.
+Make edits to a file in a single edit_file call instead of multiple edit_file calls to the same file. The apply model can handle many distinct edits at once.`;
+var EDIT_FILE_SYSTEM_PROMPT = `When the user is asking for edits to their code, use the edit_file tool to highlight the changes necessary and add comments to indicate where unchanged code has been skipped. For example:
+
+// ... existing code ...
+{{ edit_1 }}
+// ... existing code ...
+{{ edit_2 }}
+// ... existing code ...
+
+Often this will mean that the start/end of the file will be skipped, but that's okay! Rewrite the entire file ONLY if specifically requested. Always provide a brief explanation of the updates, unless the user specifically requests only the code.
+
+These edit codeblocks are also read by a less intelligent language model, colloquially called the apply model, to update the file. To help specify the edit to the apply model, you will be very careful when generating the codeblock to not introduce ambiguity. You will specify all unchanged regions (code and comments) of the file with "// ... existing code ..." comment markers. This will ensure the apply model will not delete existing unchanged code or comments when editing the file.`;
+
+// tools/fastapply/openai.ts
+var editFileTool = {
+  type: "function",
+  function: {
+    name: "edit_file",
+    description: EDIT_FILE_TOOL_DESCRIPTION,
+    parameters: {
+      type: "object",
+      properties: {
+        target_filepath: {
+          type: "string",
+          description: "The path of the target file to modify"
+        },
+        instructions: {
+          type: "string",
+          description: "A single sentence describing what you are changing (first person)"
+        },
+        code_edit: {
+          type: "string",
+          description: "The lazy edit with // ... existing code ... markers"
+        }
+      },
+      required: ["target_filepath", "instructions", "code_edit"]
+    }
+  }
+};
+async function execute2(input, config) {
+  return executeEditFile(input, config);
+}
+function getSystemPrompt2() {
+  return EDIT_FILE_SYSTEM_PROMPT;
+}
+function formatResult3(result) {
+  if (!result.success) {
+    return `Error editing file: ${result.error}`;
+  }
+  const { changes } = result;
+  const summary = [
+    changes.linesAdded && `+${changes.linesAdded} lines`,
+    changes.linesRemoved && `-${changes.linesRemoved} lines`,
+    changes.linesModified && `~${changes.linesModified} lines modified`
+  ].filter(Boolean).join(", ");
+  if (result.udiff) {
+    return `Successfully applied changes to ${result.filepath}:
+
+${result.udiff}
+
+Summary: ${summary}`;
+  }
+  return `Successfully applied changes to ${result.filepath}. ${summary}`;
+}
+function createEditFileTool(config = {}) {
+  const toolDef = {
+    ...editFileTool,
+    ...config.description && {
+      function: {
+        ...editFileTool.function,
+        description: config.description
+      }
+    }
+  };
+  return Object.assign({}, toolDef, {
+    execute: async (input) => {
+      const parsedInput = typeof input === "string" ? JSON.parse(input) : input;
+      return execute2(parsedInput, config);
+    },
+    formatResult: (result) => {
+      return formatResult3(result);
+    },
+    getSystemPrompt: () => {
+      return getSystemPrompt2();
+    }
+  });
+}
+
+// factories/openai.ts
+var OpenAIToolFactory = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create an OpenAI-compatible warp grep tool
+   * 
+   * @param toolConfig - Tool configuration (apiKey inherited from MorphClient)
+   * @returns OpenAI ChatCompletionTool with execute and formatResult methods
+   */
+  createWarpGrepTool(toolConfig) {
+    return createMorphWarpGrepTool({
+      ...toolConfig,
+      apiKey: this.config.apiKey
+    });
+  }
+  /**
+   * Create an OpenAI-compatible codebase search tool
+   * 
+   * @param toolConfig - Tool configuration with repoId (apiKey inherited from MorphClient)
+   * @returns OpenAI ChatCompletionTool with execute and formatResult methods
+   */
+  createCodebaseSearchTool(toolConfig) {
+    return createCodebaseSearchTool({
+      ...toolConfig,
+      apiKey: this.config.apiKey
+    });
+  }
+  /**
+   * Create an OpenAI-compatible edit file tool
+   * 
+   * @param toolConfig - Tool configuration (morphApiKey inherited from MorphClient)
+   * @returns OpenAI ChatCompletionTool with execute and formatResult methods
+   */
+  createEditFileTool(toolConfig = {}) {
+    return createEditFileTool({
+      ...toolConfig,
+      morphApiKey: this.config.apiKey
+    });
+  }
+};
+
+// tools/warp_grep/anthropic.ts
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    query: { type: "string", description: "Free-form repository question" }
+  },
+  required: ["query"]
+};
+async function execute3(input, config) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const result = await runWarpGrep({
+    query: parsed.query,
+    repoRoot: config.repoRoot,
+    provider,
+    excludes: config.excludes,
+    includes: config.includes,
+    debug: config.debug ?? false,
+    apiKey: config.apiKey
+  });
+  const finish = result.finish;
+  if (result.terminationReason !== "completed" || !finish?.metadata) {
+    return { success: false, error: "Search did not complete" };
+  }
+  const contexts = (finish.resolved ?? []).map((r) => ({
+    file: r.path,
+    content: r.content
+  }));
+  return { success: true, contexts, summary: finish.payload };
+}
+function createMorphWarpGrepTool2(config) {
+  const tool4 = {
+    name: "morph-warp-grep",
+    description: config.description ?? WARP_GREP_DESCRIPTION,
+    input_schema: INPUT_SCHEMA
+  };
+  return Object.assign(tool4, {
+    execute: async (input) => {
+      return execute3(input, config);
+    },
+    formatResult: (result) => {
+      return formatResult(result);
+    },
+    getSystemPrompt: () => {
+      return getSystemPrompt();
+    }
+  });
+}
+
+// tools/codebase_search/anthropic.ts
+function createCodebaseSearchTool2(config) {
+  const toolDefinition = {
+    name: "codebase_search",
+    description: CODEBASE_SEARCH_DESCRIPTION,
+    input_schema: {
+      type: "object",
+      properties: {
+        explanation: {
+          type: "string",
+          description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal."
+        },
+        query: {
+          type: "string",
+          description: 'A complete question about what you want to understand. Ask as if talking to a colleague: "How does X work?", "What happens when Y?", "Where is Z handled?"'
+        },
+        target_directories: {
+          type: "array",
+          items: { type: "string" },
+          description: "Prefix directory paths to limit search scope (single directory only, no glob patterns). Use [] to search entire repo."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results to return (default: 10)"
+        }
+      },
+      required: ["query", "target_directories", "explanation"]
+    },
+    cache_control: { type: "ephemeral" }
+  };
+  return Object.assign(toolDefinition, {
+    execute: async (input) => {
+      return executeCodebaseSearch(input, config);
+    },
+    formatResult: (result) => {
+      return formatResult4(result);
+    },
+    getSystemPrompt: () => {
+      return CODEBASE_SEARCH_SYSTEM_PROMPT;
+    }
+  });
+}
+function formatResult4(result) {
+  if (!result.success) {
+    return `Search failed: ${result.error}`;
+  }
+  if (result.results.length === 0) {
+    return "No matching code found. Try rephrasing your query or broadening the search scope.";
+  }
+  const lines = [];
+  lines.push(`Found ${result.results.length} relevant code sections (searched ${result.stats.candidatesRetrieved} candidates in ${result.stats.searchTimeMs}ms):
+`);
+  result.results.forEach((r, i) => {
+    const relevance = (r.rerankScore * 100).toFixed(1);
+    lines.push(`${i + 1}. ${r.filepath} (${relevance}% relevant)`);
+    lines.push(`   Symbol: ${r.symbolPath}`);
+    lines.push(`   Language: ${r.language}`);
+    lines.push(`   Lines: ${r.startLine}-${r.endLine}`);
+    lines.push(`   Code:`);
+    const codeLines = r.content.split("\n");
+    codeLines.slice(0, Math.min(codeLines.length, 20)).forEach((line) => {
+      lines.push(`     ${line}`);
+    });
+    if (codeLines.length > 20) {
+      lines.push(`     ... (${codeLines.length - 20} more lines)`);
+    }
+    lines.push("");
+  });
+  return lines.join("\n");
+}
+
+// tools/fastapply/anthropic.ts
+var editFileTool2 = {
+  name: "edit_file",
+  description: EDIT_FILE_TOOL_DESCRIPTION,
+  input_schema: {
+    type: "object",
+    properties: {
+      target_filepath: {
+        type: "string",
+        description: "The path of the target file to modify"
+      },
+      instructions: {
+        type: "string",
+        description: "A single sentence describing what you are changing (first person)"
+      },
+      code_edit: {
+        type: "string",
+        description: "The lazy edit with // ... existing code ... markers"
+      }
+    },
+    required: ["target_filepath", "instructions", "code_edit"]
+  }
+};
+function formatResult5(result) {
+  if (!result.success) {
+    return `Error editing file: ${result.error}`;
+  }
+  const { changes } = result;
+  const summary = [
+    changes.linesAdded && `+${changes.linesAdded} lines`,
+    changes.linesRemoved && `-${changes.linesRemoved} lines`,
+    changes.linesModified && `~${changes.linesModified} lines modified`
+  ].filter(Boolean).join(", ");
+  if (result.udiff) {
+    return `Successfully applied changes to ${result.filepath}:
+
+${result.udiff}
+
+Summary: ${summary}`;
+  }
+  return `Successfully applied changes to ${result.filepath}. ${summary}`;
+}
+function createEditFileTool2(config = {}) {
+  const toolDef = {
+    ...editFileTool2,
+    ...config.description && { description: config.description }
+  };
+  return Object.assign({}, toolDef, {
+    execute: async (input) => {
+      return executeEditFile(input, config);
+    },
+    formatResult: (result) => {
+      return formatResult5(result);
+    },
+    getSystemPrompt: () => {
+      return EDIT_FILE_SYSTEM_PROMPT;
+    }
+  });
+}
+
+// factories/anthropic.ts
+var AnthropicToolFactory = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create an Anthropic-compatible warp grep tool
+   * 
+   * @param toolConfig - Tool configuration (apiKey inherited from MorphClient)
+   * @returns Anthropic Tool with execute and formatResult methods
+   */
+  createWarpGrepTool(toolConfig) {
+    return createMorphWarpGrepTool2({
+      ...toolConfig,
+      apiKey: this.config.apiKey
+    });
+  }
+  /**
+   * Create an Anthropic-compatible codebase search tool
+   * 
+   * @param toolConfig - Tool configuration with repoId (apiKey inherited from MorphClient)
+   * @returns Anthropic Tool with execute and formatResult methods
+   */
+  createCodebaseSearchTool(toolConfig) {
+    return createCodebaseSearchTool2({
+      ...toolConfig,
+      apiKey: this.config.apiKey
+    });
+  }
+  /**
+   * Create an Anthropic-compatible edit file tool
+   * 
+   * @param toolConfig - Tool configuration (morphApiKey inherited from MorphClient)
+   * @returns Anthropic Tool with execute and formatResult methods
+   */
+  createEditFileTool(toolConfig = {}) {
+    return createEditFileTool2({
+      ...toolConfig,
+      morphApiKey: this.config.apiKey
+    });
+  }
+};
+
+// tools/warp_grep/vercel.ts
+var import_ai = require("ai");
+var import_zod = require("zod");
+var warpGrepSchema = import_zod.z.object({
+  query: import_zod.z.string().describe("Free-form repository question")
+});
+function createMorphWarpGrepTool3(config) {
+  return (0, import_ai.tool)({
+    description: config.description ?? WARP_GREP_DESCRIPTION,
+    inputSchema: warpGrepSchema,
+    execute: async (params) => {
+      const provider = config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+      const result = await runWarpGrep({
+        query: params.query,
+        repoRoot: config.repoRoot,
+        provider,
+        excludes: config.excludes,
+        includes: config.includes,
+        debug: config.debug ?? false,
+        apiKey: config.apiKey
+      });
+      const finish = result.finish;
+      if (result.terminationReason !== "completed" || !finish?.metadata) {
+        return { success: false, error: "Search did not complete" };
+      }
+      const contexts = (finish.resolved ?? []).map((r) => ({
+        file: r.path,
+        content: r.content
+      }));
+      return { success: true, contexts, summary: finish.payload };
+    }
+  });
+}
+
+// tools/codebase_search/vercel.ts
+var import_ai2 = require("ai");
+var import_zod2 = require("zod");
+function createCodebaseSearchTool3(config) {
+  const schema = import_zod2.z.object({
+    query: import_zod2.z.string().describe('A complete question about what you want to understand. Ask as if talking to a colleague: "How does X work?", "What happens when Y?", "Where is Z handled?"'),
+    target_directories: import_zod2.z.array(import_zod2.z.string()).describe("Prefix directory paths to limit search scope (single directory only, no glob patterns). Use [] to search entire repo."),
+    explanation: import_zod2.z.string().describe("One sentence explanation as to why this tool is being used, and how it contributes to the goal."),
+    limit: import_zod2.z.number().optional().describe("Max results to return (default: 10)")
+  });
+  return (0, import_ai2.tool)({
+    description: CODEBASE_SEARCH_DESCRIPTION,
+    inputSchema: schema,
+    execute: async (params) => {
+      const { query, target_directories, explanation, limit } = params;
+      const result = await executeCodebaseSearch(
+        { query, target_directories, explanation, limit },
+        config
+      );
+      if (!result.success) {
+        return {
+          error: result.error,
+          results: []
+        };
+      }
+      return {
+        found: result.results.length,
+        searchTime: `${result.stats.searchTimeMs}ms`,
+        results: result.results.map((r) => ({
+          file: r.filepath,
+          symbol: r.symbolPath,
+          lines: `${r.startLine}-${r.endLine}`,
+          language: r.language,
+          relevance: `${(r.rerankScore * 100).toFixed(1)}%`,
+          code: r.content
+        }))
+      };
+    }
+  });
+}
+
+// tools/fastapply/vercel.ts
+var import_ai3 = require("ai");
+var import_zod3 = require("zod");
+var editFileSchema = import_zod3.z.object({
+  target_filepath: import_zod3.z.string().describe("The path of the target file to modify"),
+  instructions: import_zod3.z.string().describe("A single sentence describing what you are changing (first person)"),
+  code_edit: import_zod3.z.string().describe("The lazy edit with // ... existing code ... markers")
+});
+var editFileTool3 = (0, import_ai3.tool)({
+  description: EDIT_FILE_TOOL_DESCRIPTION,
+  inputSchema: editFileSchema,
+  execute: async (params) => {
+    const result = await executeEditFile({
+      target_filepath: params.target_filepath,
+      instructions: params.instructions,
+      code_edit: params.code_edit
+    });
+    if (!result.success) {
+      throw new Error(`Failed to edit file: ${result.error}`);
+    }
+    return {
+      success: true,
+      filepath: result.filepath,
+      changes: result.changes,
+      udiff: result.udiff
+    };
+  }
+});
+function createEditFileTool3(config = {}) {
+  const schema = import_zod3.z.object({
+    target_filepath: import_zod3.z.string().describe("The path of the target file to modify"),
+    instructions: import_zod3.z.string().describe("A single sentence describing what you are changing (first person)"),
+    code_edit: import_zod3.z.string().describe("The lazy edit with // ... existing code ... markers")
+  });
+  return (0, import_ai3.tool)({
+    description: config.description || EDIT_FILE_TOOL_DESCRIPTION,
+    inputSchema: schema,
+    execute: async (params) => {
+      const result = await executeEditFile(
+        {
+          target_filepath: params.target_filepath,
+          instructions: params.instructions,
+          code_edit: params.code_edit
+        },
+        config
+      );
+      if (!result.success) {
+        throw new Error(`Failed to edit file: ${result.error}`);
+      }
+      return {
+        success: true,
+        filepath: result.filepath,
+        changes: result.changes,
+        udiff: result.udiff
+      };
+    }
+  });
+}
+
+// factories/vercel.ts
+var VercelToolFactory = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a Vercel AI SDK-compatible warp grep tool
+   * 
+   * @param toolConfig - Tool configuration (apiKey inherited from MorphClient)
+   * @returns Vercel AI SDK tool
+   */
+  createWarpGrepTool(toolConfig) {
+    return createMorphWarpGrepTool3({
+      ...toolConfig,
+      apiKey: this.config.apiKey
+    });
+  }
+  /**
+   * Create a Vercel AI SDK-compatible codebase search tool
+   * 
+   * @param toolConfig - Tool configuration with repoId (apiKey inherited from MorphClient)
+   * @returns Vercel AI SDK tool
+   */
+  createCodebaseSearchTool(toolConfig) {
+    return createCodebaseSearchTool3({
+      ...toolConfig,
+      apiKey: this.config.apiKey
+    });
+  }
+  /**
+   * Create a Vercel AI SDK-compatible edit file tool
+   * 
+   * @param toolConfig - Tool configuration (morphApiKey inherited from MorphClient)
+   * @returns Vercel AI SDK tool
+   */
+  createEditFileTool(toolConfig = {}) {
+    return createEditFileTool3({
+      ...toolConfig,
+      morphApiKey: this.config.apiKey
+    });
+  }
+};
+
 // client.ts
 var MorphClient = class {
   /** Client configuration */
@@ -1555,12 +3439,20 @@ var MorphClient = class {
   fastApply;
   /** CodebaseSearch tool for semantic code search */
   codebaseSearch;
+  /** WarpGrep tool for fast code search using ripgrep */
+  warpGrep;
   /** Browser tool for AI-powered browser automation */
   browser;
   /** Git tool for version control operations */
   git;
   /** Model routers for intelligent model selection */
   routers;
+  /** OpenAI-compatible tool factories */
+  openai;
+  /** Anthropic-compatible tool factories */
+  anthropic;
+  /** Vercel AI SDK tool factories */
+  vercel;
   /**
    * Create a new Morph SDK client
    * 
@@ -1589,6 +3481,12 @@ var MorphClient = class {
       timeout: config.timeout,
       retryConfig: config.retryConfig
     });
+    this.warpGrep = new WarpGrepClient({
+      apiKey: config.apiKey,
+      debug: config.debug,
+      timeout: config.timeout,
+      retryConfig: config.retryConfig
+    });
     this.browser = new BrowserClient({
       apiKey: config.apiKey,
       debug: config.debug,
@@ -1625,6 +3523,9 @@ var MorphClient = class {
         retryConfig: config.retryConfig
       })
     };
+    this.openai = new OpenAIToolFactory(config);
+    this.anthropic = new AnthropicToolFactory(config);
+    this.vercel = new VercelToolFactory(config);
   }
 };
 // Annotate the CommonJS export names for ESM import in node: