@morphllm/morphsdk 0.2.102 → 0.2.103

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,40 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// index.ts
-var index_exports = {};
-__export(index_exports, {
-  AnthropicRouter: () => AnthropicRouter,
-  AnthropicToolFactory: () => AnthropicToolFactory,
-  BrowserClient: () => BrowserClient,
-  CodebaseSearchClient: () => CodebaseSearchClient,
-  FastApplyClient: () => FastApplyClient,
-  GeminiRouter: () => GeminiRouter,
-  LocalRipgrepProvider: () => LocalRipgrepProvider,
-  MorphClient: () => MorphClient,
-  MorphGit: () => MorphGit,
-  OpenAIRouter: () => OpenAIRouter,
-  OpenAIToolFactory: () => OpenAIToolFactory,
-  RawRouter: () => RawRouter,
-  VercelToolFactory: () => VercelToolFactory,
-  WarpGrepClient: () => WarpGrepClient,
-  applyEdit: () => applyEdit
-});
-module.exports = __toCommonJS(index_exports);
-
-// tools/fastapply/core.ts
-var import_promises = require("fs/promises");
-var import_path = require("path");
-var import_diff = require("diff");
-
 // tools/utils/resilience.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  initialDelay: 1e3,
-  maxDelay: 3e4,
-  backoffMultiplier: 2,
-  retryableErrors: ["ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND"]
-};
 async function fetchWithRetry(url, options, retryConfig = {}) {
   const {
     maxRetries = DEFAULT_RETRY_CONFIG.maxRetries,
@@ -126,63 +96,28 @@ async function withTimeout(promise, timeoutMs, errorMessage) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-
-// tools/fastapply/core.ts
-var DEFAULT_CONFIG = {
-  morphApiUrl: "https://api.morphllm.com",
-  baseDir: process.cwd(),
-  generateUdiff: true,
-  autoWrite: true,
-  timeout: 3e4,
-  debug: false
-};
-var FastApplyClient = class {
-  config;
-  constructor(config = {}) {
-    this.config = {
-      morphApiKey: config.apiKey,
-      morphApiUrl: DEFAULT_CONFIG.morphApiUrl,
-      debug: config.debug,
-      timeout: config.timeout || DEFAULT_CONFIG.timeout,
-      retryConfig: config.retryConfig,
-      generateUdiff: DEFAULT_CONFIG.generateUdiff,
-      autoWrite: DEFAULT_CONFIG.autoWrite
+var DEFAULT_RETRY_CONFIG;
+var init_resilience = __esm({
+  "tools/utils/resilience.ts"() {
+    "use strict";
+    DEFAULT_RETRY_CONFIG = {
+      maxRetries: 3,
+      initialDelay: 1e3,
+      maxDelay: 3e4,
+      backoffMultiplier: 2,
+      retryableErrors: ["ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND"]
     };
   }
-  /**
-   * Execute a file edit operation
-   * 
-   * @param input - Edit parameters including filepath, instructions, and code_edit
-   * @param overrides - Optional config overrides for this operation
-   * @returns Edit result with success status and changes
-   */
-  async execute(input, overrides) {
-    return executeEditFile(input, { ...this.config, ...overrides });
-  }
-  /**
-   * Apply an edit to code directly without file I/O
-   * 
-   * Useful for sandbox environments or when you manage your own file system.
-   * Compatible with the earlier OpenAI client API contract.
-   * 
-   * @param input - Code and edit parameters
-   * @param overrides - Optional config overrides for this operation
-   * @returns Result with merged code
-   * 
-   * @example
-   * ```typescript
-   * const result = await client.applyEdit({
-   *   originalCode: 'function hello() { return "world"; }',
-   *   codeEdit: 'function hello() { return "universe"; }',
-   *   instructions: 'Change return value'
-   * });
-   * console.log(result.mergedCode);
-   * ```
-   */
-  async applyEdit(input, overrides) {
-    return applyEdit(input, { ...this.config, ...overrides });
-  }
-};
+});
+
+// tools/fastapply/apply.ts
+var apply_exports = {};
+__export(apply_exports, {
+  applyEdit: () => applyEdit,
+  callMorphAPI: () => callMorphAPI,
+  countChanges: () => countChanges,
+  generateUdiff: () => generateUdiff
+});
 function generateUdiff(original, modified, filepath) {
   return (0, import_diff.createTwoFilesPatch)(
     filepath,
@@ -213,9 +148,9 @@ function countChanges(original, modified) {
   };
 }
 async function callMorphAPI(originalCode, codeEdit, instructions, filepath, config) {
-  const apiKey = config.morphApiKey || process.env.MORPH_API_KEY;
-  const apiUrl = config.morphApiUrl || DEFAULT_CONFIG.morphApiUrl;
-  const timeout = config.timeout || DEFAULT_CONFIG.timeout;
+  const apiKey = config.morphApiKey || (typeof process !== "undefined" ? process.env?.MORPH_API_KEY : void 0);
+  const apiUrl = config.morphApiUrl || DEFAULT_API_URL;
+  const timeout = config.timeout || DEFAULT_TIMEOUT;
   const debug = config.debug || false;
   if (!apiKey) {
     throw new Error(
@@ -263,54 +198,6 @@ async function callMorphAPI(originalCode, codeEdit, instructions, filepath, conf
   }
   return data.choices[0].message.content;
 }
-async function executeEditFile(input, config = {}) {
-  const baseDir = config.baseDir || DEFAULT_CONFIG.baseDir;
-  const fullPath = (0, import_path.resolve)((0, import_path.join)(baseDir, input.target_filepath));
-  const debug = config.debug || false;
-  const relativePath = (0, import_path.relative)(baseDir, fullPath);
-  if (relativePath.startsWith("..") || fullPath === baseDir) {
-    return {
-      success: false,
-      filepath: input.target_filepath,
-      changes: { linesAdded: 0, linesRemoved: 0, linesModified: 0 },
-      error: `Invalid filepath: '${input.target_filepath}' is outside baseDir`
-    };
-  }
-  try {
-    if (debug) console.log(`[FastApply] Reading file: ${input.target_filepath}`);
-    let originalCode = "";
-    try {
-      originalCode = await (0, import_promises.readFile)(fullPath, "utf-8");
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-      if (debug) console.log(`[FastApply] File doesn't exist, will create new file`);
-    }
-    const mergedCode = await callMorphAPI(originalCode, input.code_edit, input.instructions, input.target_filepath, config);
-    const udiff = config.generateUdiff !== false ? generateUdiff(originalCode, mergedCode, input.target_filepath) : void 0;
-    if (config.autoWrite !== false) {
-      await (0, import_promises.writeFile)(fullPath, mergedCode, "utf-8");
-      if (debug) console.log(`[FastApply] Wrote ${mergedCode.length} chars to ${input.target_filepath}`);
-    }
-    const changes = countChanges(originalCode, mergedCode);
-    return {
-      success: true,
-      filepath: input.target_filepath,
-      udiff,
-      changes
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-    if (debug) console.error(`[FastApply] Error: ${errorMessage}`);
-    return {
-      success: false,
-      filepath: input.target_filepath,
-      changes: { linesAdded: 0, linesRemoved: 0, linesModified: 0 },
-      error: errorMessage
-    };
-  }
-}
 async function applyEdit(input, config = {}) {
   const debug = config.debug || false;
   const filepath = input.filepath || "file";
@@ -343,1198 +230,1880 @@ async function applyEdit(input, config = {}) {
     };
   }
 }
+var import_diff, DEFAULT_API_URL, DEFAULT_TIMEOUT;
+var init_apply = __esm({
+  "tools/fastapply/apply.ts"() {
+    "use strict";
+    import_diff = require("diff");
+    init_resilience();
+    DEFAULT_API_URL = "https://api.morphllm.com";
+    DEFAULT_TIMEOUT = 3e4;
+  }
+});
 
-// tools/codebase_search/core.ts
-var CodebaseSearchClient = class {
-  config;
-  constructor(config = {}) {
-    this.config = {
-      apiKey: config.apiKey,
-      searchUrl: process.env.MORPH_SEARCH_URL || "https://repos.morphllm.com",
-      debug: config.debug,
-      timeout: config.timeout || 3e4,
-      retryConfig: config.retryConfig
+// tools/warp_grep/agent/config.ts
+var parseEnvTimeout, AGENT_CONFIG, BUILTIN_EXCLUDES, DEFAULT_EXCLUDES, DEFAULT_MODEL;
+var init_config = __esm({
+  "tools/warp_grep/agent/config.ts"() {
+    "use strict";
+    parseEnvTimeout = (envValue, defaultMs) => {
+      if (!envValue) return defaultMs;
+      const parsed = parseInt(envValue, 10);
+      return isNaN(parsed) || parsed <= 0 ? defaultMs : parsed;
     };
+    AGENT_CONFIG = {
+      MAX_TURNS: 4,
+      /** Default timeout for model calls. Can be overridden via MORPH_WARP_GREP_TIMEOUT env var (in ms) */
+      TIMEOUT_MS: parseEnvTimeout(process.env.MORPH_WARP_GREP_TIMEOUT, 3e4),
+      MAX_CONTEXT_CHARS: 54e4,
+      MAX_OUTPUT_LINES: 200,
+      MAX_READ_LINES: 800,
+      MAX_LIST_DEPTH: 3,
+      LIST_TIMEOUT_MS: 2e3
+    };
+    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
+      ".*"
+    ];
+    DEFAULT_EXCLUDES = (process.env.MORPH_WARP_GREP_EXCLUDE || "").split(",").map((s) => s.trim()).filter(Boolean).concat(BUILTIN_EXCLUDES);
+    DEFAULT_MODEL = "morph-warp-grep-v1";
   }
-  /**
-   * Execute a semantic code search
-   * 
-   * @param input - Search parameters including query, repoId, and target directories
-   * @param overrides - Optional config overrides for this operation
-   * @returns Search results with ranked code matches
-   */
-  async search(input, overrides) {
-    return executeCodebaseSearch(
-      {
-        query: input.query,
-        target_directories: input.target_directories,
-        explanation: input.explanation,
-        limit: input.limit
-      },
-      { ...this.config, repoId: input.repoId, ...overrides }
-    );
-  }
-};
-async function executeCodebaseSearch(input, config) {
-  const apiKey = config.apiKey || process.env.MORPH_API_KEY;
-  if (!apiKey) {
-    throw new Error("MORPH_API_KEY not found. Set environment variable or pass in config");
-  }
-  const searchUrl = config.searchUrl || process.env.MORPH_SEARCH_URL || "https://repos.morphllm.com";
-  const timeout = config.timeout || 3e4;
-  const debug = config.debug || false;
-  if (debug) {
-    console.log(`[CodebaseSearch] Query: "${input.query.slice(0, 60)}..." repo=${config.repoId}`);
-    console.log(`[CodebaseSearch] URL: ${searchUrl}/v1/codebase_search`);
+});
+
+// tools/warp_grep/utils/ripgrep.ts
+function spawnRg(rgBinary, args, opts) {
+  return new Promise((resolve2) => {
+    const child = (0, import_child_process.spawn)(rgBinary, 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.", exitCode: -1 });
+    });
+  });
+}
+function isBinaryFailure(result) {
+  if (result.exitCode === -1) return true;
+  if (result.stderr.includes("jemalloc") || result.stderr.includes("Unsupported system page size")) return true;
+  if (result.exitCode === 134) return true;
+  return false;
+}
+async function runRipgrep(args, opts) {
+  if (rgPathChecked && resolvedRgPath) {
+    return spawnRg(resolvedRgPath, args, opts);
   }
-  const startTime = Date.now();
-  try {
-    const fetchPromise = fetchWithRetry(
-      `${searchUrl}/v1/codebase_search`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          query: input.query,
-          repoId: config.repoId,
-          targetDirectories: input.target_directories || [],
-          limit: input.limit || 10,
-          candidateLimit: 50
-        })
-      },
-      config.retryConfig
-    );
-    const response = await withTimeout(fetchPromise, timeout, `Codebase search timed out after ${timeout}ms`);
-    if (!response.ok) {
-      const errorText = await response.text();
-      if (debug) console.error(`[CodebaseSearch] Error: ${response.status} - ${errorText}`);
-      return {
-        success: false,
-        results: [],
-        stats: { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: 0 },
-        error: `Search failed (${response.status}): ${errorText}`
-      };
+  if (!rgPathChecked) {
+    const result = await spawnRg(import_ripgrep.rgPath, args, opts);
+    if (!isBinaryFailure(result)) {
+      resolvedRgPath = import_ripgrep.rgPath;
+      rgPathChecked = true;
+      return result;
     }
-    const data = await response.json();
-    const elapsed = Date.now() - startTime;
-    if (debug) {
-      console.log(`[CodebaseSearch] \u2705 ${data.results?.length || 0} results in ${elapsed}ms`);
+    const fallbackResult = await spawnRg("rg", args, opts);
+    if (!isBinaryFailure(fallbackResult)) {
+      resolvedRgPath = "rg";
+      rgPathChecked = true;
+      return fallbackResult;
     }
+    rgPathChecked = true;
     return {
-      success: true,
-      results: data.results || [],
-      stats: data.stats || { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: elapsed }
-    };
-  } catch (error) {
-    if (debug) console.error(`[CodebaseSearch] Exception: ${error instanceof Error ? error.message : error}`);
-    return {
-      success: false,
-      results: [],
-      stats: { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: 0 },
-      error: error instanceof Error ? error.message : "Unknown error"
+      stdout: "",
+      stderr: "Failed to spawn ripgrep. Neither bundled nor system rg is available.",
+      exitCode: -1
     };
   }
+  return {
+    stdout: "",
+    stderr: "Failed to spawn ripgrep. Neither bundled nor system rg is available.",
+    exitCode: -1
+  };
 }
-
-// tools/browser/live.ts
-var LIVE_PRESETS = {
-  /** Read-only monitoring (no interaction) */
-  readonly: { interactive: false },
-  /** Interactive control (human-in-the-loop) */
-  interactive: { interactive: true },
-  /** Watch-only without controls */
-  monitoring: { interactive: false, showControls: false }
-};
-function buildLiveUrl(debugUrl, options = {}) {
-  if (!debugUrl) {
-    throw new Error(
-      "debugUrl is required. Ensure your backend returns debugUrl in the task response. Contact support@morphllm.com if you need help."
-    );
-  }
-  const normalized = normalizeLiveUrl(debugUrl);
-  const url = new URL(normalized);
-  if (options.interactive !== void 0) {
-    url.searchParams.set("interactive", String(options.interactive));
-  }
-  if (options.theme) {
-    url.searchParams.set("theme", options.theme);
-  }
-  if (options.showControls !== void 0) {
-    url.searchParams.set("showControls", String(options.showControls));
-  }
-  if (options.pageId) {
-    url.searchParams.set("pageId", options.pageId);
+var import_child_process, import_ripgrep, resolvedRgPath, rgPathChecked;
+var init_ripgrep = __esm({
+  "tools/warp_grep/utils/ripgrep.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_ripgrep = require("@vscode/ripgrep");
+    resolvedRgPath = null;
+    rgPathChecked = false;
   }
-  if (options.pageIndex) {
-    url.searchParams.set("pageIndex", options.pageIndex);
-  }
-  return url.toString();
+});
+
+// tools/warp_grep/utils/paths.ts
+function resolveUnderRepo(repoRoot, targetPath) {
+  const absRoot = import_path4.default.resolve(repoRoot);
+  const resolved = import_path4.default.resolve(absRoot, targetPath);
+  ensureWithinRepo(absRoot, resolved);
+  return resolved;
 }
-function normalizeLiveUrl(debugUrl) {
-  const trimmed = debugUrl.trim();
-  if (!trimmed) {
-    return trimmed;
-  }
-  if (trimmed.startsWith("wss://") || trimmed.startsWith("ws://")) {
-    return `https://live.browser-use.com?wss=${encodeURIComponent(trimmed)}`;
+function ensureWithinRepo(repoRoot, absTarget) {
+  const rel = import_path4.default.relative(import_path4.default.resolve(repoRoot), import_path4.default.resolve(absTarget));
+  if (rel.startsWith("..") || import_path4.default.isAbsolute(rel)) {
+    throw new Error(`Path outside repository root: ${absTarget}`);
   }
-  let url;
+}
+function toRepoRelative(repoRoot, absPath) {
+  return import_path4.default.relative(import_path4.default.resolve(repoRoot), import_path4.default.resolve(absPath));
+}
+function isSymlink(p) {
   try {
-    url = new URL(trimmed);
+    const st = import_fs.default.lstatSync(p);
+    return st.isSymbolicLink();
   } catch {
-    return trimmed;
-  }
-  if (url.protocol === "wss:" || url.protocol === "ws:") {
-    return `https://live.browser-use.com?wss=${encodeURIComponent(trimmed)}`;
-  }
-  const wssParam = url.searchParams.get("wss");
-  if (wssParam && (wssParam.startsWith("wss://") || wssParam.startsWith("ws://"))) {
-    url.searchParams.set("wss", wssParam);
-  }
-  return url.toString();
-}
-function buildLiveIframe(debugUrl, options = {}) {
-  const {
-    width = "100%",
-    height = "600px",
-    style = "",
-    className = "",
-    ...sessionOptions
-  } = options;
-  const src = buildLiveUrl(debugUrl, sessionOptions);
-  const widthStr = typeof width === "number" ? `${width}px` : width;
-  const heightStr = typeof height === "number" ? `${height}px` : height;
-  const baseStyle = `width: ${widthStr}; height: ${heightStr}; border: none;`;
-  const fullStyle = style ? `${baseStyle} ${style}` : baseStyle;
-  const attributes = [
-    `src="${src}"`,
-    `style="${fullStyle}"`
-  ];
-  if (className) {
-    attributes.push(`class="${className}"`);
+    return false;
   }
-  return `<iframe ${attributes.join(" ")}></iframe>`;
 }
-function buildEmbedCode(debugUrl, options = {}) {
-  const iframe = buildLiveIframe(debugUrl, options);
-  return `<!-- Embed Morph Live Session -->
-${iframe}`;
-}
-function resolvePreset(optionsOrPreset) {
-  if (!optionsOrPreset) {
-    return {};
-  }
-  if (typeof optionsOrPreset === "string") {
-    const preset = LIVE_PRESETS[optionsOrPreset];
-    if (!preset) {
-      throw new Error(
-        `Unknown preset: ${optionsOrPreset}. Available presets: ${Object.keys(LIVE_PRESETS).join(", ")}`
-      );
+function fixPathRepetition(fullPath) {
+  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++) {
+      const first = segments.slice(i, i + len);
+      const second = segments.slice(i + len, i + 2 * len);
+      if (first.every((seg, idx) => seg === second[idx])) {
+        const fixed = [...segments.slice(0, i), ...segments.slice(i + len)];
+        return import_path4.default.sep + fixed.join(import_path4.default.sep);
+      }
     }
-    return preset;
   }
-  return optionsOrPreset;
+  return null;
 }
-
-// tools/browser/errors.ts
-var MorphError = class extends Error {
-  /** Error code for programmatic handling */
-  code;
-  /** Original cause of the error, if any */
-  cause;
-  constructor(message, code, cause) {
-    super(message);
-    this.name = "MorphError";
-    this.code = code;
-    this.cause = cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
+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;
   }
-  /**
-   * Returns a JSON representation of the error for logging.
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      code: this.code,
-      cause: this.cause?.message
-    };
-  }
-};
-var MorphValidationError = class extends MorphError {
-  /** The field that failed validation */
-  field;
-  constructor(message, field) {
-    super(message, "validation_error");
-    this.name = "MorphValidationError";
-    this.field = field;
+}
+var import_fs, import_path4;
+var init_paths = __esm({
+  "tools/warp_grep/utils/paths.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"), 1);
+    import_path4 = __toESM(require("path"), 1);
   }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      field: this.field
-    };
+});
+
+// tools/warp_grep/utils/files.ts
+async function readAllLines(filePath) {
+  const content = await import_promises.default.readFile(filePath, "utf8");
+  return content.split(/\r?\n/);
+}
+var import_promises;
+var init_files = __esm({
+  "tools/warp_grep/utils/files.ts"() {
+    "use strict";
+    import_promises = __toESM(require("fs/promises"), 1);
   }
-};
-var MorphAPIError = class extends MorphError {
-  /** HTTP status code */
-  statusCode;
-  /** Request ID for debugging (if available) */
-  requestId;
-  /** Raw response body */
-  rawResponse;
-  constructor(message, code, statusCode, options) {
-    super(message, code, options?.cause);
-    this.name = "MorphAPIError";
-    this.statusCode = statusCode;
-    this.requestId = options?.requestId;
-    this.rawResponse = options?.rawResponse;
+});
+
+// tools/warp_grep/providers/local.ts
+var local_exports = {};
+__export(local_exports, {
+  LocalRipgrepProvider: () => LocalRipgrepProvider
+});
+function shouldSkip2(name) {
+  if (SKIP_NAMES2.has(name)) return true;
+  if (name.startsWith(".")) return true;
+  for (const ext of SKIP_EXTENSIONS2) {
+    if (name.endsWith(ext)) return true;
   }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      statusCode: this.statusCode,
-      requestId: this.requestId
+  return false;
+}
+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_path5 = __toESM(require("path"), 1);
+    init_ripgrep();
+    init_paths();
+    init_files();
+    init_config();
+    SKIP_NAMES2 = /* @__PURE__ */ new Set([
+      // Version control
+      ".git",
+      ".svn",
+      ".hg",
+      ".bzr",
+      // Dependencies
+      "node_modules",
+      "bower_components",
+      ".pnpm",
+      ".yarn",
+      "vendor",
+      "Pods",
+      ".bundle",
+      // Python
+      "__pycache__",
+      ".pytest_cache",
+      ".mypy_cache",
+      ".ruff_cache",
+      ".venv",
+      "venv",
+      ".tox",
+      ".nox",
+      ".eggs",
+      // Build outputs
+      "dist",
+      "build",
+      "out",
+      "output",
+      "target",
+      "_build",
+      ".next",
+      ".nuxt",
+      ".output",
+      ".vercel",
+      ".netlify",
+      // Cache
+      ".cache",
+      ".parcel-cache",
+      ".turbo",
+      ".nx",
+      ".gradle",
+      // IDE
+      ".idea",
+      ".vscode",
+      ".vs",
+      // Coverage
+      "coverage",
+      ".coverage",
+      "htmlcov",
+      ".nyc_output",
+      // Temp
+      "tmp",
+      "temp",
+      ".tmp",
+      ".temp",
+      // Lock files
+      "package-lock.json",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      "bun.lockb",
+      "Cargo.lock",
+      "Gemfile.lock",
+      "poetry.lock"
+    ]);
+    SKIP_EXTENSIONS2 = /* @__PURE__ */ new Set([
+      ".min.js",
+      ".min.css",
+      ".bundle.js",
+      ".wasm",
+      ".so",
+      ".dll",
+      ".pyc",
+      ".map",
+      ".js.map"
+    ]);
+    LocalRipgrepProvider = class {
+      constructor(repoRoot, excludes = DEFAULT_EXCLUDES) {
+        this.repoRoot = repoRoot;
+        this.excludes = excludes;
+      }
+      async grep(params) {
+        let abs;
+        try {
+          abs = resolveUnderRepo(this.repoRoot, params.path);
+        } catch (err) {
+          return {
+            lines: [],
+            error: `[PATH ERROR] ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+        const stat = await import_promises2.default.stat(abs).catch(() => null);
+        if (!stat) return { lines: [] };
+        const targetArg = abs === import_path5.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
+        const args = [
+          "--no-config",
+          "--no-heading",
+          "--with-filename",
+          "--line-number",
+          "--color=never",
+          "--trim",
+          "--max-columns=400",
+          "-C",
+          "1",
+          ...params.glob ? ["--glob", params.glob] : [],
+          ...this.excludes.flatMap((e) => ["-g", `!${e}`]),
+          params.pattern,
+          targetArg || "."
+        ];
+        const res = await runRipgrep(args, { cwd: this.repoRoot });
+        if (res.exitCode === -1) {
+          return {
+            lines: [],
+            error: `[RIPGREP NOT AVAILABLE] ripgrep (rg) is required but failed to execute. Please install it:
+  \u2022 macOS: brew install ripgrep
+  \u2022 Ubuntu/Debian: apt install ripgrep
+  \u2022 Windows: choco install ripgrep
+  \u2022 Or visit: https://github.com/BurntSushi/ripgrep#installation
+Exit code: ${res.exitCode}${res.stderr ? `
+Details: ${res.stderr}` : ""}`
+          };
+        }
+        if (res.exitCode !== 0 && res.exitCode !== 1) {
+          return {
+            lines: [],
+            error: `[RIPGREP ERROR] grep failed with exit code ${res.exitCode}${res.stderr ? `: ${res.stderr}` : ""}`
+          };
+        }
+        const lines = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
+        if (lines.length > AGENT_CONFIG.MAX_OUTPUT_LINES) {
+          return {
+            lines: [],
+            error: "query not specific enough, tool tried to return too much context and failed"
+          };
+        }
+        return { lines };
+      }
+      async read(params) {
+        let abs;
+        try {
+          abs = resolveUnderRepo(this.repoRoot, params.path);
+        } catch (err) {
+          return {
+            lines: [],
+            error: `[PATH ERROR] ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+        let stat = await import_promises2.default.stat(abs).catch(() => null);
+        if (!stat || !stat.isFile()) {
+          const fixedPath = fixPathRepetition(abs);
+          if (fixedPath) {
+            const fixedStat = await import_promises2.default.stat(fixedPath).catch(() => null);
+            if (fixedStat?.isFile()) {
+              abs = fixedPath;
+              stat = fixedStat;
+            }
+          }
+        }
+        if (!stat || !stat.isFile()) {
+          return {
+            lines: [],
+            error: `[FILE NOT FOUND] You tried to read "${params.path}" but there is no file at this path. Double-check the path exists and is spelled correctly.`
+          };
+        }
+        if (isSymlink(abs)) {
+          return {
+            lines: [],
+            error: `[SYMLINK] You tried to read "${params.path}" but this is a symlink. Try reading the actual file it points to instead.`
+          };
+        }
+        if (!isTextualFile(abs)) {
+          return {
+            lines: [],
+            error: `[UNREADABLE FILE] You tried to read "${params.path}" but this file is either too large or not a text file, so it cannot be read. Try a different file.`
+          };
+        }
+        let lines;
+        try {
+          lines = await readAllLines(abs);
+        } catch (err) {
+          return {
+            lines: [],
+            error: `[READ ERROR] Failed to read "${params.path}": ${err instanceof Error ? err.message : String(err)}`
+          };
+        }
+        const total = lines.length;
+        const rawStart = params.start;
+        const rawEnd = params.end;
+        let s = 1;
+        let e = total;
+        const startValid = rawStart === void 0 || Number.isFinite(rawStart) && rawStart > 0;
+        const endValid = rawEnd === void 0 || Number.isFinite(rawEnd) && rawEnd > 0;
+        if (startValid && endValid) {
+          s = rawStart ?? 1;
+          e = Math.min(rawEnd ?? total, total);
+          if (s > total && total > 0 || s > e) {
+            s = 1;
+            e = total;
+          }
+        }
+        const out = [];
+        for (let i = s; i <= e; i += 1) {
+          const content = lines[i - 1] ?? "";
+          out.push(`${i}|${content}`);
+        }
+        if (out.length > AGENT_CONFIG.MAX_READ_LINES) {
+          const truncated = out.slice(0, AGENT_CONFIG.MAX_READ_LINES);
+          truncated.push(`... [truncated: showing ${AGENT_CONFIG.MAX_READ_LINES} of ${out.length} lines]`);
+          return { lines: truncated };
+        }
+        return { lines: out };
+      }
+      async listDirectory(params) {
+        let abs;
+        try {
+          abs = resolveUnderRepo(this.repoRoot, params.path);
+        } catch {
+          return [];
+        }
+        const stat = await import_promises2.default.stat(abs).catch(() => null);
+        if (!stat || !stat.isDirectory()) {
+          return [];
+        }
+        const maxResults = params.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
+        const maxDepth = params.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
+        const regex = params.pattern ? new RegExp(params.pattern) : null;
+        const repoRoot = this.repoRoot;
+        const results = [];
+        let timedOut = false;
+        const startTime = Date.now();
+        async function walk(dir, depth) {
+          if (Date.now() - startTime > AGENT_CONFIG.LIST_TIMEOUT_MS) {
+            timedOut = true;
+            return;
+          }
+          if (depth > maxDepth || results.length >= maxResults) return;
+          const entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (timedOut || results.length >= maxResults) break;
+            if (shouldSkip2(entry.name)) continue;
+            if (regex && !regex.test(entry.name)) continue;
+            const full = import_path5.default.join(dir, entry.name);
+            const isDir = entry.isDirectory();
+            results.push({
+              name: entry.name,
+              path: toRepoRelative(repoRoot, full),
+              type: isDir ? "dir" : "file",
+              depth
+            });
+            if (isDir) {
+              await walk(full, depth + 1);
+            }
+          }
+        }
+        await walk(abs, 0);
+        return results;
+      }
     };
   }
+});
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnthropicRouter: () => AnthropicRouter,
+  AnthropicToolFactory: () => AnthropicToolFactory,
+  BrowserClient: () => BrowserClient,
+  CodebaseSearchClient: () => CodebaseSearchClient,
+  FastApplyClient: () => FastApplyClient,
+  GeminiRouter: () => GeminiRouter,
+  LocalRipgrepProvider: () => LocalRipgrepProvider,
+  MorphClient: () => MorphClient,
+  MorphGit: () => MorphGit,
+  OpenAIRouter: () => OpenAIRouter,
+  OpenAIToolFactory: () => OpenAIToolFactory,
+  RawRouter: () => RawRouter,
+  VercelToolFactory: () => VercelToolFactory,
+  WarpGrepClient: () => WarpGrepClient,
+  applyEdit: () => applyEdit
+});
+module.exports = __toCommonJS(index_exports);
+
+// tools/fastapply/core.ts
+var import_path = require("path");
+init_apply();
+var DEFAULT_CONFIG = {
+  morphApiUrl: "https://api.morphllm.com",
+  baseDir: process.cwd(),
+  generateUdiff: true,
+  autoWrite: true,
+  timeout: 3e4,
+  debug: false
 };
-var MorphAuthenticationError = class extends MorphAPIError {
-  constructor(message = "Authentication required. Please provide a valid API key.") {
-    super(message, "authentication_required", 401);
-    this.name = "MorphAuthenticationError";
-  }
-};
-var MorphRateLimitError = class extends MorphAPIError {
-  /** When the rate limit resets (Unix timestamp) */
-  resetAt;
-  /** Number of seconds until reset */
-  retryAfter;
-  constructor(message = "Rate limit exceeded. Please retry later.", options) {
-    super(message, "rate_limit_exceeded", 429, { requestId: options?.requestId });
-    this.name = "MorphRateLimitError";
-    this.resetAt = options?.resetAt;
-    this.retryAfter = options?.retryAfter;
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      resetAt: this.resetAt,
-      retryAfter: this.retryAfter
+var FastApplyClient = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      morphApiKey: config.apiKey,
+      morphApiUrl: DEFAULT_CONFIG.morphApiUrl,
+      debug: config.debug,
+      timeout: config.timeout || DEFAULT_CONFIG.timeout,
+      retryConfig: config.retryConfig,
+      generateUdiff: DEFAULT_CONFIG.generateUdiff,
+      autoWrite: DEFAULT_CONFIG.autoWrite
     };
   }
-};
-var MorphNotFoundError = class extends MorphAPIError {
-  /** The type of resource that was not found */
-  resourceType;
-  /** The ID of the resource that was not found */
-  resourceId;
-  constructor(resourceType, resourceId) {
-    const message = resourceId ? `${resourceType} '${resourceId}' not found` : `${resourceType} not found`;
-    super(message, "resource_not_found", 404);
-    this.name = "MorphNotFoundError";
-    this.resourceType = resourceType;
-    this.resourceId = resourceId;
+  /**
+   * Execute a file edit operation
+   *
+   * @param input - Edit parameters including filepath, instructions, and code_edit
+   * @param overrides - Optional config overrides for this operation
+   * @returns Edit result with success status and changes
+   */
+  async execute(input, overrides) {
+    return executeEditFile(input, { ...this.config, ...overrides });
   }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      resourceType: this.resourceType,
-      resourceId: this.resourceId
-    };
+  /**
+   * Apply an edit to code directly without file I/O
+   *
+   * Useful for sandbox environments or when you manage your own file system.
+   * Compatible with the earlier OpenAI client API contract.
+   *
+   * @param input - Code and edit parameters
+   * @param overrides - Optional config overrides for this operation
+   * @returns Result with merged code
+   *
+   * @example
+   * ```typescript
+   * const result = await client.applyEdit({
+   *   originalCode: 'function hello() { return "world"; }',
+   *   codeEdit: 'function hello() { return "universe"; }',
+   *   instructions: 'Change return value'
+   * });
+   * console.log(result.mergedCode);
+   * ```
+   */
+  async applyEdit(input, overrides) {
+    const { applyEdit: applyEdit2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
+    return applyEdit2(input, { ...this.config, ...overrides });
   }
 };
-var MorphProfileLimitError = class extends MorphAPIError {
-  /** Current number of profiles */
-  currentCount;
-  /** Maximum allowed profiles for the plan */
-  maxAllowed;
-  constructor(message = "Profile limit exceeded for your plan.", options) {
-    super(message, "profile_limit_exceeded", 403, { requestId: options?.requestId });
-    this.name = "MorphProfileLimitError";
-    this.currentCount = options?.currentCount;
-    this.maxAllowed = options?.maxAllowed;
-  }
-  toJSON() {
+async function executeEditFile(input, config = {}) {
+  const baseDir = config.baseDir || DEFAULT_CONFIG.baseDir;
+  const fullPath = (0, import_path.resolve)((0, import_path.join)(baseDir, input.target_filepath));
+  const debug = config.debug || false;
+  const relativePath = (0, import_path.relative)(baseDir, fullPath);
+  if (relativePath.startsWith("..") || fullPath === baseDir) {
     return {
-      ...super.toJSON(),
-      currentCount: this.currentCount,
-      maxAllowed: this.maxAllowed
+      success: false,
+      filepath: input.target_filepath,
+      changes: { linesAdded: 0, linesRemoved: 0, linesModified: 0 },
+      error: `Invalid filepath: '${input.target_filepath}' is outside baseDir`
     };
   }
-};
-function parseAPIError(statusCode, responseText, requestId) {
-  let errorData = {};
   try {
-    errorData = JSON.parse(responseText);
-  } catch {
-  }
-  const message = errorData.detail || errorData.message || responseText || "Unknown error";
-  const code = errorData.code;
-  switch (statusCode) {
-    case 401:
-      return new MorphAuthenticationError(message);
-    case 403:
-      if (code === "profile_limit_exceeded" || message.toLowerCase().includes("limit")) {
-        return new MorphProfileLimitError(message, { requestId });
-      }
-      return new MorphAPIError(message, "insufficient_permissions", statusCode, { requestId, rawResponse: responseText });
-    case 404:
-      if (message.toLowerCase().includes("profile")) {
-        return new MorphNotFoundError("Profile", void 0);
-      }
-      if (message.toLowerCase().includes("session")) {
-        return new MorphNotFoundError("Session", void 0);
+    if (debug) console.log(`[FastApply] Reading file: ${input.target_filepath}`);
+    const { readFile, writeFile } = await import("fs/promises");
+    const { callMorphAPI: callMorphAPI2, generateUdiff: generateUdiff2, countChanges: countChanges2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
+    let originalCode = "";
+    try {
+      originalCode = await readFile(fullPath, "utf-8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
       }
-      return new MorphAPIError(message, "resource_not_found", statusCode, { requestId, rawResponse: responseText });
-    case 429:
-      return new MorphRateLimitError(message, { requestId });
-    case 422:
-      return new MorphAPIError(message, "validation_error", statusCode, { requestId, rawResponse: responseText });
-    case 500:
-    case 502:
-    case 503:
-    case 504:
-      return new MorphAPIError(message, "service_unavailable", statusCode, { requestId, rawResponse: responseText });
-    default:
-      return new MorphAPIError(message, "network_error", statusCode, { requestId, rawResponse: responseText });
+      if (debug) console.log(`[FastApply] File doesn't exist, will create new file`);
+    }
+    const mergedCode = await callMorphAPI2(originalCode, input.code_edit, input.instructions, input.target_filepath, config);
+    const udiff = config.generateUdiff !== false ? generateUdiff2(originalCode, mergedCode, input.target_filepath) : void 0;
+    if (config.autoWrite !== false) {
+      await writeFile(fullPath, mergedCode, "utf-8");
+      if (debug) console.log(`[FastApply] Wrote ${mergedCode.length} chars to ${input.target_filepath}`);
+    }
+    const changes = countChanges2(originalCode, mergedCode);
+    return {
+      success: true,
+      filepath: input.target_filepath,
+      udiff,
+      changes
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+    if (debug) console.error(`[FastApply] Error: ${errorMessage}`);
+    return {
+      success: false,
+      filepath: input.target_filepath,
+      changes: { linesAdded: 0, linesRemoved: 0, linesModified: 0 },
+      error: errorMessage
+    };
   }
 }
 
-// tools/browser/profiles/types.ts
-function transformProfile(api) {
-  return {
-    id: api.id,
-    name: api.name,
-    repoId: api.repo_id,
-    cookieDomains: api.cookie_domains,
-    lastUsedAt: api.last_used_at,
-    createdAt: api.created_at,
-    updatedAt: api.updated_at
-  };
-}
-function transformCreateInput(input) {
-  return {
-    name: input.name,
-    repo_id: input.repoId
-  };
-}
-function transformSession(api) {
-  return {
-    sessionId: api.session_id,
-    debugUrl: api.debug_url || ""
-  };
-}
-function transformSaveInput(input) {
-  return {
-    session_id: input.sessionId,
-    profile_id: input.profileId
-  };
-}
-function transformStateResponse(api) {
-  return {
-    profileId: api.profile_id,
-    stateUrl: api.state_url,
-    expiresIn: api.expires_in
-  };
-}
-
-// tools/browser/profiles/core.ts
-var DEFAULT_API_URL = process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com";
-var ProfilesClient = class {
+// tools/codebase_search/core.ts
+init_resilience();
+var CodebaseSearchClient = class {
   config;
-  constructor(config) {
-    this.config = config;
+  constructor(config = {}) {
+    this.config = {
+      apiKey: config.apiKey,
+      searchUrl: process.env.MORPH_SEARCH_URL || "https://repos.morphllm.com",
+      debug: config.debug,
+      timeout: config.timeout || 3e4,
+      retryConfig: config.retryConfig
+    };
   }
   /**
-    * Create a new browser profile and immediately start a live session.
-    *
-    * @param input - Profile creation parameters
-    * @returns Profile setup handle with live URL + save()
-    * @throws {MorphValidationError} If input validation fails
-    * @throws {MorphProfileLimitError} If profile limit is exceeded
-    * @throws {MorphAuthenticationError} If API key is missing or invalid
-    *
-    * @example
-    * ```typescript
-  * const setup = await morph.browser.profiles.createProfile({
-  *   name: 'LinkedIn Production',
-  *   repoId: 'owner/repo'
-  * });
-  * console.log(setup.session.debugUrl);
-  * await setup.save();
-    * ```
-    */
-  async createProfile(input) {
-    return createProfile(input, this.config);
-  }
-  /**
-   * List all profiles for the authenticated user.
-   *
-   * @param repoId - Optional repository ID to filter by
-   * @returns Array of profiles
-   *
-   * @example
-   * ```typescript
-   * // List all profiles
-   * const allProfiles = await morph.browser.profiles.listProfiles();
-   *
-   * // List profiles for a specific repo
-   * const repoProfiles = await morph.browser.profiles.listProfiles('owner/repo');
-   * ```
+   * Execute a semantic code search
+   * 
+   * @param input - Search parameters including query, repoId, and target directories
+   * @param overrides - Optional config overrides for this operation
+   * @returns Search results with ranked code matches
    */
-  async listProfiles(repoId) {
-    return listProfiles(this.config, repoId);
+  async search(input, overrides) {
+    return executeCodebaseSearch(
+      {
+        query: input.query,
+        target_directories: input.target_directories,
+        explanation: input.explanation,
+        limit: input.limit
+      },
+      { ...this.config, repoId: input.repoId, ...overrides }
+    );
   }
-  /**
-   * Get a profile by ID with convenience methods.
-   *
-   * @param id - Profile ID
-   * @returns Profile with attached methods
-   * @throws {MorphNotFoundError} If profile is not found
-   *
-   * @example
-   * ```typescript
-   * const profile = await morph.browser.profiles.getProfile('profile-id');
-   * const state = await profile.getState();
-   * await profile.delete();
-   * ```
-   */
-  async getProfile(id) {
-    return getProfile(id, this.config);
+};
+async function executeCodebaseSearch(input, config) {
+  const apiKey = config.apiKey || process.env.MORPH_API_KEY;
+  if (!apiKey) {
+    throw new Error("MORPH_API_KEY not found. Set environment variable or pass in config");
   }
-  /**
-   * Update a profile by opening a live session (no rename).
-   *
-   * @param id - Profile ID
-   * @returns Profile setup handle with live URL + save()
-   */
-  async updateProfile(id) {
-    return updateProfile(id, this.config);
+  const searchUrl = config.searchUrl || process.env.MORPH_SEARCH_URL || "https://repos.morphllm.com";
+  const timeout = config.timeout || 3e4;
+  const debug = config.debug || false;
+  if (debug) {
+    console.log(`[CodebaseSearch] Query: "${input.query.slice(0, 60)}..." repo=${config.repoId}`);
+    console.log(`[CodebaseSearch] URL: ${searchUrl}/v1/codebase_search`);
   }
-  /**
-   * Delete a profile.
-   *
-   * @param id - Profile ID
-   * @throws {MorphNotFoundError} If profile is not found
-   */
-  async deleteProfile(id) {
-    return deleteProfile(id, this.config);
+  const startTime = Date.now();
+  try {
+    const fetchPromise = fetchWithRetry(
+      `${searchUrl}/v1/codebase_search`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          query: input.query,
+          repoId: config.repoId,
+          targetDirectories: input.target_directories || [],
+          limit: input.limit || 10,
+          candidateLimit: 50
+        })
+      },
+      config.retryConfig
+    );
+    const response = await withTimeout(fetchPromise, timeout, `Codebase search timed out after ${timeout}ms`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (debug) console.error(`[CodebaseSearch] Error: ${response.status} - ${errorText}`);
+      return {
+        success: false,
+        results: [],
+        stats: { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: 0 },
+        error: `Search failed (${response.status}): ${errorText}`
+      };
+    }
+    const data = await response.json();
+    const elapsed = Date.now() - startTime;
+    if (debug) {
+      console.log(`[CodebaseSearch] \u2705 ${data.results?.length || 0} results in ${elapsed}ms`);
+    }
+    return {
+      success: true,
+      results: data.results || [],
+      stats: data.stats || { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: elapsed }
+    };
+  } catch (error) {
+    if (debug) console.error(`[CodebaseSearch] Exception: ${error instanceof Error ? error.message : error}`);
+    return {
+      success: false,
+      results: [],
+      stats: { totalResults: 0, candidatesRetrieved: 0, searchTimeMs: 0 },
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
   }
-  /**
-   * Start a browser session for profile setup.
-   *
-   * Returns a live URL where the user can sign into accounts.
-   * After signing in, call `saveSession` to persist the state.
-   *
-   * @param input - Optional session parameters
-   * @returns Session with debug URL
-   *
-   * @example
-   * ```typescript
-   * const session = await morph.browser.profiles.startSession();
-   * console.log('Sign in at:', session.debugUrl);
-   * // Open debugUrl in browser, user signs in...
-   * await morph.browser.profiles.saveSession(session.sessionId, profile.id);
-   * ```
-   */
-  async startSession(input) {
-    return startProfileSession(this.config, input);
+}
+
+// tools/browser/core.ts
+init_resilience();
+
+// tools/browser/live.ts
+var LIVE_PRESETS = {
+  /** Read-only monitoring (no interaction) */
+  readonly: { interactive: false },
+  /** Interactive control (human-in-the-loop) */
+  interactive: { interactive: true },
+  /** Watch-only without controls */
+  monitoring: { interactive: false, showControls: false }
+};
+function buildLiveUrl(debugUrl, options = {}) {
+  if (!debugUrl) {
+    throw new Error(
+      "debugUrl is required. Ensure your backend returns debugUrl in the task response. Contact support@morphllm.com if you need help."
+    );
   }
-  /**
-   * Save browser state from a session to a profile.
-   *
-   * Call this after the user is done signing into accounts.
-   * Extracts cookies, localStorage, and sessionStorage.
-   *
-   * @param sessionId - Browser session ID from startSession
-   * @param profileId - Profile ID to save state to
-   * @returns Updated profile with cookie domains
-   */
-  async saveSession(sessionId, profileId) {
-    return saveProfileSession({ sessionId, profileId }, this.config);
+  const normalized = normalizeLiveUrl(debugUrl);
+  const url = new URL(normalized);
+  if (options.interactive !== void 0) {
+    url.searchParams.set("interactive", String(options.interactive));
   }
-  /**
-   * List available repo IDs (discovery).
-   *
-   * @returns Repo summaries with profile counts
-   */
-  async listRepos() {
-    return listRepos(this.config);
+  if (options.theme) {
+    url.searchParams.set("theme", options.theme);
   }
-  /**
-   * Get the presigned URL for a profile's state.
-   *
-   * Use this to download the raw state JSON for debugging
-   * or to restore state manually.
-   *
-   * @param profileId - Profile ID
-   * @returns State URL with expiry information
-   */
-  async getProfileState(profileId) {
-    return getProfileState(profileId, this.config);
+  if (options.showControls !== void 0) {
+    url.searchParams.set("showControls", String(options.showControls));
   }
-};
-function validateCreateInput(input) {
-  if (!input.name || typeof input.name !== "string") {
-    throw new MorphValidationError("name is required", "name");
+  if (options.pageId) {
+    url.searchParams.set("pageId", options.pageId);
   }
-  const trimmedName = input.name.trim();
-  if (trimmedName.length === 0) {
-    throw new MorphValidationError("name cannot be empty", "name");
+  if (options.pageIndex) {
+    url.searchParams.set("pageIndex", options.pageIndex);
   }
-  if (trimmedName.length > 100) {
-    throw new MorphValidationError("name must be 100 characters or less", "name");
+  return url.toString();
+}
+function normalizeLiveUrl(debugUrl) {
+  const trimmed = debugUrl.trim();
+  if (!trimmed) {
+    return trimmed;
   }
-  if (!input.repoId || typeof input.repoId !== "string") {
-    throw new MorphValidationError("repoId is required", "repoId");
+  if (trimmed.startsWith("wss://") || trimmed.startsWith("ws://")) {
+    return `https://live.browser-use.com?wss=${encodeURIComponent(trimmed)}`;
   }
-  if (input.repoId.trim().length === 0) {
-    throw new MorphValidationError("repoId cannot be empty", "repoId");
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return trimmed;
   }
-}
-function validateId(id, fieldName) {
-  if (!id || typeof id !== "string") {
-    throw new MorphValidationError(`${fieldName} is required`, fieldName);
+  if (url.protocol === "wss:" || url.protocol === "ws:") {
+    return `https://live.browser-use.com?wss=${encodeURIComponent(trimmed)}`;
   }
-  if (id.trim().length === 0) {
-    throw new MorphValidationError(`${fieldName} cannot be empty`, fieldName);
+  const wssParam = url.searchParams.get("wss");
+  if (wssParam && (wssParam.startsWith("wss://") || wssParam.startsWith("ws://"))) {
+    url.searchParams.set("wss", wssParam);
   }
+  return url.toString();
 }
-async function createProfile(input, config = {}) {
-  validateCreateInput(input);
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const response = await fetchWithRetry(
-    `${apiUrl}/profiles`,
-    {
-      method: "POST",
-      headers,
-      body: JSON.stringify(transformCreateInput(input))
-    },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+function buildLiveIframe(debugUrl, options = {}) {
+  const {
+    width = "100%",
+    height = "600px",
+    style = "",
+    className = "",
+    ...sessionOptions
+  } = options;
+  const src = buildLiveUrl(debugUrl, sessionOptions);
+  const widthStr = typeof width === "number" ? `${width}px` : width;
+  const heightStr = typeof height === "number" ? `${height}px` : height;
+  const baseStyle = `width: ${widthStr}; height: ${heightStr}; border: none;`;
+  const fullStyle = style ? `${baseStyle} ${style}` : baseStyle;
+  const attributes = [
+    `src="${src}"`,
+    `style="${fullStyle}"`
+  ];
+  if (className) {
+    attributes.push(`class="${className}"`);
   }
-  const apiProfile = await response.json();
-  const profile = transformProfile(apiProfile);
-  const session = await startProfileSession(config, { profileId: profile.id });
-  return buildProfileSetup(profile, session, config);
+  return `<iframe ${attributes.join(" ")}></iframe>`;
 }
-async function listProfiles(config = {}, repoId) {
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const url = repoId ? `${apiUrl}/profiles?repo_id=${encodeURIComponent(repoId)}` : `${apiUrl}/profiles`;
-  const response = await fetchWithRetry(
-    url,
-    { method: "GET", headers },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
-  }
-  const data = await response.json();
-  return data.profiles.map(transformProfile);
+function buildEmbedCode(debugUrl, options = {}) {
+  const iframe = buildLiveIframe(debugUrl, options);
+  return `<!-- Embed Morph Live Session -->
+${iframe}`;
 }
-async function getProfile(id, config = {}) {
-  validateId(id, "id");
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const response = await fetchWithRetry(
-    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
-    { method: "GET", headers },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+function resolvePreset(optionsOrPreset) {
+  if (!optionsOrPreset) {
+    return {};
   }
-  const apiProfile = await response.json();
-  const profile = transformProfile(apiProfile);
-  return {
-    ...profile,
-    getState: () => getProfileState(id, config),
-    delete: () => deleteProfile(id, config)
-  };
-}
-async function updateProfile(id, config = {}) {
-  validateId(id, "id");
-  const profile = await fetchProfile(id, config);
-  const session = await startProfileSession(config, { profileId: profile.id });
-  return buildProfileSetup(profile, session, config);
-}
-async function deleteProfile(id, config = {}) {
-  validateId(id, "id");
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const response = await fetchWithRetry(
-    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
-    { method: "DELETE", headers },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+  if (typeof optionsOrPreset === "string") {
+    const preset = LIVE_PRESETS[optionsOrPreset];
+    if (!preset) {
+      throw new Error(
+        `Unknown preset: ${optionsOrPreset}. Available presets: ${Object.keys(LIVE_PRESETS).join(", ")}`
+      );
+    }
+    return preset;
   }
+  return optionsOrPreset;
 }
-async function startProfileSession(config = {}, input) {
-  if (!config.apiKey) {
-    throw new MorphAuthenticationError();
+
+// tools/browser/profiles/core.ts
+init_resilience();
+
+// tools/browser/errors.ts
+var MorphError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Original cause of the error, if any */
+  cause;
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "MorphError";
+    this.code = code;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
   }
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const body = input?.profileId ? { profile_id: input.profileId } : {};
-  const response = await fetchWithRetry(
-    `${apiUrl}/profiles/session/start`,
-    {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+  /**
+   * Returns a JSON representation of the error for logging.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      cause: this.cause?.message
+    };
   }
-  const apiSession = await response.json();
-  return transformSession(apiSession);
-}
-async function saveProfileSession(input, config = {}) {
-  validateId(input.sessionId, "sessionId");
-  validateId(input.profileId, "profileId");
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const response = await fetchWithRetry(
-    `${apiUrl}/profiles/session/save`,
-    {
-      method: "POST",
-      headers,
-      body: JSON.stringify(transformSaveInput(input))
-    },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+};
+var MorphValidationError = class extends MorphError {
+  /** The field that failed validation */
+  field;
+  constructor(message, field) {
+    super(message, "validation_error");
+    this.name = "MorphValidationError";
+    this.field = field;
   }
-  const apiProfile = await response.json();
-  return transformProfile(apiProfile);
-}
-async function listRepos(config = {}) {
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const response = await fetchWithRetry(
-    `${apiUrl}/repos`,
-    { method: "GET", headers },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      field: this.field
+    };
   }
-  const data = await response.json();
-  const repos = Array.isArray(data?.repos) ? data.repos : [];
-  return repos.map((repo) => ({
-    repoId: repo.repo_id,
-    repoFullName: repo.repo_full_name,
-    profileCount: repo.profile_count ?? 0
-  }));
-}
-async function getProfileState(profileId, config = {}) {
-  validateId(profileId, "profileId");
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const response = await fetchWithRetry(
-    `${apiUrl}/profiles/${encodeURIComponent(profileId)}/state`,
-    { method: "GET", headers },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+};
+var MorphAPIError = class extends MorphError {
+  /** HTTP status code */
+  statusCode;
+  /** Request ID for debugging (if available) */
+  requestId;
+  /** Raw response body */
+  rawResponse;
+  constructor(message, code, statusCode, options) {
+    super(message, code, options?.cause);
+    this.name = "MorphAPIError";
+    this.statusCode = statusCode;
+    this.requestId = options?.requestId;
+    this.rawResponse = options?.rawResponse;
   }
-  const apiState = await response.json();
-  return transformStateResponse(apiState);
-}
-function buildHeaders(config) {
-  const headers = { "Content-Type": "application/json" };
-  if (config.apiKey) {
-    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      statusCode: this.statusCode,
+      requestId: this.requestId
+    };
   }
-  return headers;
-}
-async function fetchProfile(id, config) {
-  const apiUrl = config.apiUrl || DEFAULT_API_URL;
-  const headers = buildHeaders(config);
-  const response = await fetchWithRetry(
-    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
-    { method: "GET", headers },
-    config.retryConfig
-  );
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => response.statusText);
-    const requestId = response.headers.get("x-request-id") || void 0;
-    throw parseAPIError(response.status, errorText, requestId);
+};
+var MorphAuthenticationError = class extends MorphAPIError {
+  constructor(message = "Authentication required. Please provide a valid API key.") {
+    super(message, "authentication_required", 401);
+    this.name = "MorphAuthenticationError";
+  }
+};
+var MorphRateLimitError = class extends MorphAPIError {
+  /** When the rate limit resets (Unix timestamp) */
+  resetAt;
+  /** Number of seconds until reset */
+  retryAfter;
+  constructor(message = "Rate limit exceeded. Please retry later.", options) {
+    super(message, "rate_limit_exceeded", 429, { requestId: options?.requestId });
+    this.name = "MorphRateLimitError";
+    this.resetAt = options?.resetAt;
+    this.retryAfter = options?.retryAfter;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      resetAt: this.resetAt,
+      retryAfter: this.retryAfter
+    };
+  }
+};
+var MorphNotFoundError = class extends MorphAPIError {
+  /** The type of resource that was not found */
+  resourceType;
+  /** The ID of the resource that was not found */
+  resourceId;
+  constructor(resourceType, resourceId) {
+    const message = resourceId ? `${resourceType} '${resourceId}' not found` : `${resourceType} not found`;
+    super(message, "resource_not_found", 404);
+    this.name = "MorphNotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      resourceType: this.resourceType,
+      resourceId: this.resourceId
+    };
+  }
+};
+var MorphProfileLimitError = class extends MorphAPIError {
+  /** Current number of profiles */
+  currentCount;
+  /** Maximum allowed profiles for the plan */
+  maxAllowed;
+  constructor(message = "Profile limit exceeded for your plan.", options) {
+    super(message, "profile_limit_exceeded", 403, { requestId: options?.requestId });
+    this.name = "MorphProfileLimitError";
+    this.currentCount = options?.currentCount;
+    this.maxAllowed = options?.maxAllowed;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      currentCount: this.currentCount,
+      maxAllowed: this.maxAllowed
+    };
+  }
+};
+function parseAPIError(statusCode, responseText, requestId) {
+  let errorData = {};
+  try {
+    errorData = JSON.parse(responseText);
+  } catch {
+  }
+  const message = errorData.detail || errorData.message || responseText || "Unknown error";
+  const code = errorData.code;
+  switch (statusCode) {
+    case 401:
+      return new MorphAuthenticationError(message);
+    case 403:
+      if (code === "profile_limit_exceeded" || message.toLowerCase().includes("limit")) {
+        return new MorphProfileLimitError(message, { requestId });
+      }
+      return new MorphAPIError(message, "insufficient_permissions", statusCode, { requestId, rawResponse: responseText });
+    case 404:
+      if (message.toLowerCase().includes("profile")) {
+        return new MorphNotFoundError("Profile", void 0);
+      }
+      if (message.toLowerCase().includes("session")) {
+        return new MorphNotFoundError("Session", void 0);
+      }
+      return new MorphAPIError(message, "resource_not_found", statusCode, { requestId, rawResponse: responseText });
+    case 429:
+      return new MorphRateLimitError(message, { requestId });
+    case 422:
+      return new MorphAPIError(message, "validation_error", statusCode, { requestId, rawResponse: responseText });
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new MorphAPIError(message, "service_unavailable", statusCode, { requestId, rawResponse: responseText });
+    default:
+      return new MorphAPIError(message, "network_error", statusCode, { requestId, rawResponse: responseText });
   }
-  const apiProfile = await response.json();
-  return transformProfile(apiProfile);
 }
-function buildProfileSetup(profile, session, config) {
+
+// tools/browser/profiles/types.ts
+function transformProfile(api) {
   return {
-    profile,
-    session,
-    save: () => saveProfileSession({ sessionId: session.sessionId, profileId: profile.id }, config)
+    id: api.id,
+    name: api.name,
+    repoId: api.repo_id,
+    cookieDomains: api.cookie_domains,
+    lastUsedAt: api.last_used_at,
+    createdAt: api.created_at,
+    updatedAt: api.updated_at
+  };
+}
+function transformCreateInput(input) {
+  return {
+    name: input.name,
+    repo_id: input.repoId
+  };
+}
+function transformSession(api) {
+  return {
+    sessionId: api.session_id,
+    debugUrl: api.debug_url || ""
+  };
+}
+function transformSaveInput(input) {
+  return {
+    session_id: input.sessionId,
+    profile_id: input.profileId
+  };
+}
+function transformStateResponse(api) {
+  return {
+    profileId: api.profile_id,
+    stateUrl: api.state_url,
+    expiresIn: api.expires_in
   };
 }
 
-// tools/browser/core.ts
-var DEFAULT_CONFIG2 = {
-  apiUrl: process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com",
-  timeout: 1e6,
-  // 10 minutes for complex tasks
-  debug: false
-};
-var BrowserClient = class {
+// tools/browser/profiles/core.ts
+var DEFAULT_API_URL2 = process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com";
+var ProfilesClient = class {
   config;
+  constructor(config) {
+    this.config = config;
+  }
   /**
-   * Profile management - create and manage browser profiles for storing login state.
+    * Create a new browser profile and immediately start a live session.
+    *
+    * @param input - Profile creation parameters
+    * @returns Profile setup handle with live URL + save()
+    * @throws {MorphValidationError} If input validation fails
+    * @throws {MorphProfileLimitError} If profile limit is exceeded
+    * @throws {MorphAuthenticationError} If API key is missing or invalid
+    *
+    * @example
+    * ```typescript
+  * const setup = await morph.browser.profiles.createProfile({
+  *   name: 'LinkedIn Production',
+  *   repoId: 'owner/repo'
+  * });
+  * console.log(setup.session.debugUrl);
+  * await setup.save();
+    * ```
+    */
+  async createProfile(input) {
+    return createProfile(input, this.config);
+  }
+  /**
+   * List all profiles for the authenticated user.
+   *
+   * @param repoId - Optional repository ID to filter by
+   * @returns Array of profiles
+   *
+   * @example
+   * ```typescript
+   * // List all profiles
+   * const allProfiles = await morph.browser.profiles.listProfiles();
+   *
+   * // List profiles for a specific repo
+   * const repoProfiles = await morph.browser.profiles.listProfiles('owner/repo');
+   * ```
    */
-  profiles;
-  constructor(config = {}) {
-    this.config = {
-      ...DEFAULT_CONFIG2,
-      ...config
-    };
-    this.profiles = new ProfilesClient(this.config);
+  async listProfiles(repoId) {
+    return listProfiles(this.config, repoId);
   }
   /**
-   * Execute a browser automation task
+   * Get a profile by ID with convenience methods.
+   *
+   * @param id - Profile ID
+   * @returns Profile with attached methods
+   * @throws {MorphNotFoundError} If profile is not found
+   *
+   * @example
+   * ```typescript
+   * const profile = await morph.browser.profiles.getProfile('profile-id');
+   * const state = await profile.getState();
+   * await profile.delete();
+   * ```
    */
-  async execute(input) {
-    return executeBrowserTask(input, this.config);
-  }
-  async createTask(input) {
-    const apiUrl = this.config.apiUrl || DEFAULT_CONFIG2.apiUrl;
-    const debug = this.config.debug || false;
-    const hasTask = typeof input.task === "string" && input.task.trim().length > 0;
-    const hasDiff = typeof input.diff === "string" && input.diff.trim().length > 0;
-    if (!hasTask && !hasDiff) {
-      throw new Error('Browser task requires either "task" (natural language) or "diff" (PR-review planning)');
-    }
-    if (debug) {
-      const preview = (input.task ?? "").slice(0, 60);
-      console.log(`[Browser] createTask: "${preview}..." 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,
-        diff: input.diff,
-        url: input.url,
-        max_steps: input.maxSteps ?? 10,
-        model: input.model ?? "morph-computer-use-v0",
-        viewport_width: input.viewportWidth ?? 1280,
-        viewport_height: input.viewportHeight ?? 720,
-        external_id: input.externalId,
-        repo_id: input.repoId,
-        repo_full_name: input.repoFullName,
-        commit_id: input.commitId,
-        record_video: input.recordVideo ?? false,
-        video_width: input.videoWidth ?? input.viewportWidth ?? 1280,
-        video_height: input.videoHeight ?? input.viewportHeight ?? 720,
-        allow_resizing: input.allowResizing ?? false,
-        structured_output: "schema" in input ? stringifyStructuredOutput(input.schema) : void 0,
-        auth: input.auth,
-        profile_id: input.profileId,
-        force_query_params: input.forceQueryParams
-      })
-    });
-    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 = mapTaskResult(await response.json());
-    if (debug) {
-      const debugUrl = result.debugUrl;
-      console.log(`[Browser] \u2705 Task created: recordingId=${result.recordingId ?? "none"} debugUrl=${debugUrl ? "available" : "none"}`);
-    }
-    if ("schema" in input) {
-      return wrapTaskResponseWithSchema(result, this.config, input.schema);
-    } else {
-      return wrapTaskResponse(result, this.config);
-    }
+  async getProfile(id) {
+    return getProfile(id, this.config);
   }
   /**
-   * Execute task with recording and wait for video to be ready
+   * Update a profile by opening a live session (no rename).
+   *
+   * @param id - Profile ID
+   * @returns Profile setup handle with live URL + save()
    */
-  async executeWithRecording(input) {
-    return executeWithRecording(input, this.config);
+  async updateProfile(id) {
+    return updateProfile(id, this.config);
   }
   /**
-   * Get recording status and URLs
+   * Delete a profile.
+   *
+   * @param id - Profile ID
+   * @throws {MorphNotFoundError} If profile is not found
    */
-  async getRecording(recordingId) {
-    return getRecording(recordingId, this.config);
+  async deleteProfile(id) {
+    return deleteProfile(id, this.config);
   }
   /**
-   * Wait for recording to complete with automatic polling
+   * Start a browser session for profile setup.
+   *
+   * Returns a live URL where the user can sign into accounts.
+   * After signing in, call `saveSession` to persist the state.
+   *
+   * @param input - Optional session parameters
+   * @returns Session with debug URL
+   *
+   * @example
+   * ```typescript
+   * const session = await morph.browser.profiles.startSession();
+   * console.log('Sign in at:', session.debugUrl);
+   * // Open debugUrl in browser, user signs in...
+   * await morph.browser.profiles.saveSession(session.sessionId, profile.id);
+   * ```
    */
-  async waitForRecording(recordingId, options) {
-    return waitForRecording(recordingId, this.config, options);
+  async startSession(input) {
+    return startProfileSession(this.config, input);
   }
   /**
-   * Get errors from recording with screenshots
+   * Save browser state from a session to a profile.
+   *
+   * Call this after the user is done signing into accounts.
+   * Extracts cookies, localStorage, and sessionStorage.
+   *
+   * @param sessionId - Browser session ID from startSession
+   * @param profileId - Profile ID to save state to
+   * @returns Updated profile with cookie domains
    */
-  async getErrors(recordingId) {
-    return getErrors(recordingId, this.config);
+  async saveSession(sessionId, profileId) {
+    return saveProfileSession({ sessionId, profileId }, this.config);
   }
   /**
-   * Get animated WebP preview of recording
+   * List available repo IDs (discovery).
+   *
+   * @returns Repo summaries with profile counts
    */
-  async getWebp(recordingId, options) {
-    return getWebp(recordingId, this.config, options);
+  async listRepos() {
+    return listRepos(this.config);
   }
   /**
-   * Check if browser worker service is healthy
+   * Get the presigned URL for a profile's state.
+   *
+   * Use this to download the raw state JSON for debugging
+   * or to restore state manually.
+   *
+   * @param profileId - Profile ID
+   * @returns State URL with expiry information
    */
-  async checkHealth() {
-    return checkHealth(this.config);
+  async getProfileState(profileId) {
+    return getProfileState(profileId, this.config);
   }
 };
-async function executeBrowserTask(input, config = {}) {
-  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
-  const timeout = config.timeout || DEFAULT_CONFIG2.timeout;
-  const debug = config.debug || false;
-  if (!input.task || input.task.trim().length === 0) {
-    return {
-      success: false,
-      error: 'Task description is required. Example: "Go to example.com and click the login button"'
-    };
+function validateCreateInput(input) {
+  if (!input.name || typeof input.name !== "string") {
+    throw new MorphValidationError("name is required", "name");
   }
-  if (input.maxSteps !== void 0 && (input.maxSteps < 1 || input.maxSteps > 50)) {
-    return {
-      success: false,
-      error: "maxSteps must be between 1 and 50. Use more steps for complex multi-page flows."
-    };
+  const trimmedName = input.name.trim();
+  if (trimmedName.length === 0) {
+    throw new MorphValidationError("name cannot be empty", "name");
   }
-  if (debug) {
-    console.log(`[Browser] Task: "${input.task.slice(0, 60)}..." url=${input.url || "none"} maxSteps=${input.maxSteps ?? 10}`);
-    console.log(`[Browser] Recording: ${input.recordVideo ? "yes" : "no"} | Calling ${apiUrl}/browser-task`);
+  if (trimmedName.length > 100) {
+    throw new MorphValidationError("name must be 100 characters or less", "name");
   }
-  const startTime = Date.now();
-  try {
-    const headers = { "Content-Type": "application/json" };
-    if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
-    const fetchPromise = fetchWithRetry(
-      `${apiUrl}/browser-task`,
-      {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          task: input.task,
-          url: input.url,
-          max_steps: input.maxSteps ?? 10,
-          model: input.model ?? "morph-computer-use-v0",
-          viewport_width: input.viewportWidth ?? 1280,
-          viewport_height: input.viewportHeight ?? 720,
-          external_id: input.externalId,
-          repo_id: input.repoId,
-          commit_id: input.commitId,
-          record_video: input.recordVideo ?? false,
-          video_width: input.videoWidth ?? input.viewportWidth ?? 1280,
-          video_height: input.videoHeight ?? input.viewportHeight ?? 720,
-          allow_resizing: input.allowResizing ?? false,
-          structured_output: input.structuredOutput,
-          auth: input.auth,
-          profile_id: input.profileId,
-          force_query_params: input.forceQueryParams
-        })
-      },
-      config.retryConfig
-    );
-    const response = await withTimeout(
-      fetchPromise,
-      timeout,
-      `Browser task timed out after ${timeout}ms. Consider increasing timeout or reducing maxSteps.`
-    );
-    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 = mapTaskResult(await response.json());
-    const elapsed = Date.now() - startTime;
-    if (debug) {
-      console.log(`[Browser] \u2705 ${result.success ? "Success" : "Failed"} in ${elapsed}ms | steps=${result.stepsTaken ?? 0} recordingId=${result.recordingId ?? "none"}`);
-    }
-    return result;
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
-        return {
-          success: false,
-          error: `Cannot connect to browser worker at ${apiUrl}. Ensure the service is running and accessible. For local dev, set MORPH_ENVIRONMENT=DEV.`
-        };
-      }
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-    return {
-      success: false,
-      error: String(error)
-    };
+  if (!input.repoId || typeof input.repoId !== "string") {
+    throw new MorphValidationError("repoId is required", "repoId");
+  }
+  if (input.repoId.trim().length === 0) {
+    throw new MorphValidationError("repoId cannot be empty", "repoId");
   }
 }
-async function getRecording(recordingId, config = {}) {
-  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
-  const debug = config.debug || false;
-  if (!config.apiKey) {
-    throw new Error("API key required for getRecording");
+function validateId(id, fieldName) {
+  if (!id || typeof id !== "string") {
+    throw new MorphValidationError(`${fieldName} is required`, fieldName);
   }
-  if (debug) console.log(`[Browser] getRecording: ${recordingId}`);
-  const response = await fetch(`${apiUrl}/recordings/${recordingId}`, {
-    method: "GET",
-    headers: { "Authorization": `Bearer ${config.apiKey}` }
-  });
+  if (id.trim().length === 0) {
+    throw new MorphValidationError(`${fieldName} cannot be empty`, fieldName);
+  }
+}
+async function createProfile(input, config = {}) {
+  validateCreateInput(input);
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(transformCreateInput(input))
+    },
+    config.retryConfig
+  );
   if (!response.ok) {
     const errorText = await response.text().catch(() => response.statusText);
-    if (debug) console.error(`[Browser] getRecording error: ${response.status} - ${errorText}`);
-    throw new Error(`HTTP ${response.status}: ${errorText}`);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
   }
-  const data = mapRecordingStatus(await response.json());
-  if (debug) console.log(`[Browser] Recording status: ${data.status}`);
-  return {
-    ...data,
-    getWebp: (options) => getWebp(recordingId, config, options),
-    getErrors: () => getErrors(recordingId, config)
-  };
+  const apiProfile = await response.json();
+  const profile = transformProfile(apiProfile);
+  const session = await startProfileSession(config, { profileId: profile.id });
+  return buildProfileSetup(profile, session, config);
 }
-async function waitForRecording(recordingId, config = {}, options = {}) {
-  const timeout = options.timeout ?? 6e4;
-  const pollInterval = options.pollInterval ?? 2e3;
-  const startTime = Date.now();
-  while (Date.now() - startTime < timeout) {
-    const status = await getRecording(recordingId, config);
-    if (status.status === "COMPLETED" || status.status === "ERROR") {
-      return status;
-    }
-    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+async function listProfiles(config = {}, repoId) {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const url = repoId ? `${apiUrl}/profiles?repo_id=${encodeURIComponent(repoId)}` : `${apiUrl}/profiles`;
+  const response = await fetchWithRetry(
+    url,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
   }
-  throw new Error(`Recording timeout after ${timeout}ms - status still pending`);
+  const data = await response.json();
+  return data.profiles.map(transformProfile);
 }
-async function executeWithRecording(input, config = {}) {
-  const taskResult = await executeBrowserTask(input, config);
-  if (taskResult.recordingId) {
-    try {
-      const recording = await waitForRecording(
-        taskResult.recordingId,
-        config,
-        { timeout: 6e4, pollInterval: 2e3 }
-      );
-      return {
-        ...taskResult,
-        recording
-      };
-    } catch (error) {
-      const errorRecording = {
-        id: taskResult.recordingId,
-        status: "ERROR",
-        error: error instanceof Error ? error.message : String(error),
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        getWebp: (options) => getWebp(taskResult.recordingId, config, options),
-        getErrors: () => getErrors(taskResult.recordingId, config)
-      };
-      return {
-        ...taskResult,
-        recording: errorRecording
-      };
-    }
+async function getProfile(id, config = {}) {
+  validateId(id, "id");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
   }
-  return taskResult;
+  const apiProfile = await response.json();
+  const profile = transformProfile(apiProfile);
+  return {
+    ...profile,
+    getState: () => getProfileState(id, config),
+    delete: () => deleteProfile(id, config)
+  };
 }
-async function getErrors(recordingId, config = {}) {
-  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
-  const debug = config.debug || false;
+async function updateProfile(id, config = {}) {
+  validateId(id, "id");
+  const profile = await fetchProfile(id, config);
+  const session = await startProfileSession(config, { profileId: profile.id });
+  return buildProfileSetup(profile, session, config);
+}
+async function deleteProfile(id, config = {}) {
+  validateId(id, "id");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "DELETE", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+}
+async function startProfileSession(config = {}, input) {
   if (!config.apiKey) {
-    throw new Error("API key required for getErrors");
+    throw new MorphAuthenticationError();
   }
-  if (debug) console.log(`[Browser] getErrors: ${recordingId}`);
-  const response = await fetch(`${apiUrl}/recordings/${recordingId}/errors`, {
-    method: "GET",
-    headers: { "Authorization": `Bearer ${config.apiKey}` }
-  });
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const body = input?.profileId ? { profile_id: input.profileId } : {};
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/session/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    },
+    config.retryConfig
+  );
   if (!response.ok) {
     const errorText = await response.text().catch(() => response.statusText);
-    if (debug) console.error(`[Browser] getErrors error: ${response.status} - ${errorText}`);
-    throw new Error(`HTTP ${response.status}: ${errorText}`);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
   }
-  const errors = mapErrorsResponse(await response.json());
-  if (debug) console.log(`[Browser] Found ${errors.totalErrors} errors`);
-  return errors;
+  const apiSession = await response.json();
+  return transformSession(apiSession);
 }
-function stringifyStructuredOutput(schema) {
-  try {
-    return JSON.stringify({
-      type: "object",
-      description: "Zod schema definition (Zod v3)",
-      zodDef: schema._def
-    });
-  } catch (error) {
-    console.warn("[Browser] Failed to serialize Zod schema:", error);
-    return JSON.stringify({
-      type: "object",
-      description: "Schema serialization failed"
-    });
+async function saveProfileSession(input, config = {}) {
+  validateId(input.sessionId, "sessionId");
+  validateId(input.profileId, "profileId");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/session/save`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify(transformSaveInput(input))
+    },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
   }
+  const apiProfile = await response.json();
+  return transformProfile(apiProfile);
 }
-function parseStructuredTaskOutput(result, schema) {
-  if (!result.output) {
-    return { ...result, parsed: null };
-  }
-  try {
-    const parsed = JSON.parse(result.output);
-    const validated = schema.parse(parsed);
-    return { ...result, parsed: validated };
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      return { ...result, parsed: null };
-    }
-    throw error;
+async function listRepos(config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/repos`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
   }
+  const data = await response.json();
+  const repos = Array.isArray(data?.repos) ? data.repos : [];
+  return repos.map((repo) => ({
+    repoId: repo.repo_id,
+    repoFullName: repo.repo_full_name,
+    profileCount: repo.profile_count ?? 0
+  }));
 }
-function mapTaskResult(api) {
-  if (!api || typeof api !== "object") {
-    return api;
+async function getProfileState(profileId, config = {}) {
+  validateId(profileId, "profileId");
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(profileId)}/state`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
   }
-  return {
-    success: api.success,
-    result: api.result,
-    error: api.error,
-    stepsTaken: api.steps_taken,
-    executionTimeMs: api.execution_time_ms,
-    urls: api.urls,
-    actionNames: api.action_names,
-    errors: api.errors,
-    modelActions: api.model_actions,
-    isDone: api.is_done,
-    actionHistory: api.action_history,
-    actionResults: api.action_results,
-    hasErrors: api.has_errors,
-    numberOfSteps: api.number_of_steps,
-    judgement: api.judgement,
-    isValidated: api.is_validated,
-    replayId: api.replay_id,
-    replayUrl: api.replay_url,
-    recordingId: api.recording_id,
-    recordingStatus: api.recording_status,
-    taskId: api.task_id,
-    status: api.status,
-    output: api.output,
-    debugUrl: api.debug_url
-  };
+  const apiState = await response.json();
+  return transformStateResponse(apiState);
 }
-function mapRecordingStatus(api) {
-  return {
-    id: api.id,
-    status: api.status,
-    replayUrl: api.replay_url,
-    networkUrl: api.network_url,
-    consoleUrl: api.console_url,
-    videoUrl: api.video_url,
-    result: api.result,
-    totalEvents: api.total_events,
-    fileSize: api.file_size,
-    duration: api.duration,
-    error: api.error,
-    createdAt: api.created_at
-  };
+function buildHeaders(config) {
+  const headers = { "Content-Type": "application/json" };
+  if (config.apiKey) {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  }
+  return headers;
 }
-function mapBrowserError(api) {
-  return {
-    type: api.type,
-    message: api.message,
-    url: api.url,
-    timestamp: api.timestamp,
-    screenshotUrl: api.screenshot_url,
-    capturedAt: api.captured_at,
-    status: api.status
-  };
+async function fetchProfile(id, config) {
+  const apiUrl = config.apiUrl || DEFAULT_API_URL2;
+  const headers = buildHeaders(config);
+  const response = await fetchWithRetry(
+    `${apiUrl}/profiles/${encodeURIComponent(id)}`,
+    { method: "GET", headers },
+    config.retryConfig
+  );
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    const requestId = response.headers.get("x-request-id") || void 0;
+    throw parseAPIError(response.status, errorText, requestId);
+  }
+  const apiProfile = await response.json();
+  return transformProfile(apiProfile);
 }
-function mapErrorsResponse(api) {
+function buildProfileSetup(profile, session, config) {
   return {
-    recordingId: api.recording_id,
-    totalErrors: api.total_errors,
-    errors: Array.isArray(api.errors) ? api.errors.map(mapBrowserError) : []
+    profile,
+    session,
+    save: () => saveProfileSession({ sessionId: session.sessionId, profileId: profile.id }, config)
   };
 }
-function mapWebpResponse(api) {
-  return {
-    webpUrl: api.webp_url,
-    cached: api.cached,
-    width: api.width,
-    fps: api.fps,
-    maxDuration: api.max_duration,
-    fileSize: api.file_size,
-    maxSizeMb: api.max_size_mb,
-    budgetMet: api.budget_met,
-    qualityUsed: api.quality_used,
-    attempts: api.attempts
-  };
+
+// tools/browser/core.ts
+var DEFAULT_CONFIG2 = {
+  apiUrl: process.env.MORPH_ENVIRONMENT === "DEV" ? "http://localhost:8000" : "https://browser.morphllm.com",
+  timeout: 1e6,
+  // 10 minutes for complex tasks
+  debug: false
+};
+var BrowserClient = class {
+  config;
+  /**
+   * Profile management - create and manage browser profiles for storing login state.
+   */
+  profiles;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG2,
+      ...config
+    };
+    this.profiles = new ProfilesClient(this.config);
+  }
+  /**
+   * Execute a browser automation task
+   */
+  async execute(input) {
+    return executeBrowserTask(input, this.config);
+  }
+  async createTask(input) {
+    const apiUrl = this.config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+    const debug = this.config.debug || false;
+    const hasTask = typeof input.task === "string" && input.task.trim().length > 0;
+    const hasDiff = typeof input.diff === "string" && input.diff.trim().length > 0;
+    if (!hasTask && !hasDiff) {
+      throw new Error('Browser task requires either "task" (natural language) or "diff" (PR-review planning)');
+    }
+    if (debug) {
+      const preview = (input.task ?? "").slice(0, 60);
+      console.log(`[Browser] createTask: "${preview}..." 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,
+        diff: input.diff,
+        url: input.url,
+        max_steps: input.maxSteps ?? 10,
+        model: input.model ?? "morph-computer-use-v0",
+        viewport_width: input.viewportWidth ?? 1280,
+        viewport_height: input.viewportHeight ?? 720,
+        external_id: input.externalId,
+        repo_id: input.repoId,
+        repo_full_name: input.repoFullName,
+        commit_id: input.commitId,
+        record_video: input.recordVideo ?? false,
+        video_width: input.videoWidth ?? input.viewportWidth ?? 1280,
+        video_height: input.videoHeight ?? input.viewportHeight ?? 720,
+        allow_resizing: input.allowResizing ?? false,
+        structured_output: "schema" in input ? stringifyStructuredOutput(input.schema) : void 0,
+        auth: input.auth,
+        profile_id: input.profileId,
+        force_query_params: input.forceQueryParams
+      })
+    });
+    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 = mapTaskResult(await response.json());
+    if (debug) {
+      const debugUrl = result.debugUrl;
+      console.log(`[Browser] \u2705 Task created: recordingId=${result.recordingId ?? "none"} debugUrl=${debugUrl ? "available" : "none"}`);
+    }
+    if ("schema" in input) {
+      return wrapTaskResponseWithSchema(result, this.config, input.schema);
+    } else {
+      return wrapTaskResponse(result, this.config);
+    }
+  }
+  /**
+   * Execute task with recording and wait for video to be ready
+   */
+  async executeWithRecording(input) {
+    return executeWithRecording(input, this.config);
+  }
+  /**
+   * Get recording status and URLs
+   */
+  async getRecording(recordingId) {
+    return getRecording(recordingId, this.config);
+  }
+  /**
+   * Wait for recording to complete with automatic polling
+   */
+  async waitForRecording(recordingId, options) {
+    return waitForRecording(recordingId, this.config, options);
+  }
+  /**
+   * Get errors from recording with screenshots
+   */
+  async getErrors(recordingId) {
+    return getErrors(recordingId, this.config);
+  }
+  /**
+   * Get animated WebP preview of recording
+   */
+  async getWebp(recordingId, options) {
+    return getWebp(recordingId, this.config, options);
+  }
+  /**
+   * Check if browser worker service is healthy
+   */
+  async checkHealth() {
+    return checkHealth(this.config);
+  }
+};
+async function executeBrowserTask(input, config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const timeout = config.timeout || DEFAULT_CONFIG2.timeout;
+  const debug = config.debug || false;
+  if (!input.task || input.task.trim().length === 0) {
+    return {
+      success: false,
+      error: 'Task description is required. Example: "Go to example.com and click the login button"'
+    };
+  }
+  if (input.maxSteps !== void 0 && (input.maxSteps < 1 || input.maxSteps > 50)) {
+    return {
+      success: false,
+      error: "maxSteps must be between 1 and 50. Use more steps for complex multi-page flows."
+    };
+  }
+  if (debug) {
+    console.log(`[Browser] Task: "${input.task.slice(0, 60)}..." url=${input.url || "none"} maxSteps=${input.maxSteps ?? 10}`);
+    console.log(`[Browser] Recording: ${input.recordVideo ? "yes" : "no"} | Calling ${apiUrl}/browser-task`);
+  }
+  const startTime = Date.now();
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+    const fetchPromise = fetchWithRetry(
+      `${apiUrl}/browser-task`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          task: input.task,
+          url: input.url,
+          max_steps: input.maxSteps ?? 10,
+          model: input.model ?? "morph-computer-use-v0",
+          viewport_width: input.viewportWidth ?? 1280,
+          viewport_height: input.viewportHeight ?? 720,
+          external_id: input.externalId,
+          repo_id: input.repoId,
+          commit_id: input.commitId,
+          record_video: input.recordVideo ?? false,
+          video_width: input.videoWidth ?? input.viewportWidth ?? 1280,
+          video_height: input.videoHeight ?? input.viewportHeight ?? 720,
+          allow_resizing: input.allowResizing ?? false,
+          structured_output: input.structuredOutput,
+          auth: input.auth,
+          profile_id: input.profileId,
+          force_query_params: input.forceQueryParams
+        })
+      },
+      config.retryConfig
+    );
+    const response = await withTimeout(
+      fetchPromise,
+      timeout,
+      `Browser task timed out after ${timeout}ms. Consider increasing timeout or reducing maxSteps.`
+    );
+    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 = mapTaskResult(await response.json());
+    const elapsed = Date.now() - startTime;
+    if (debug) {
+      console.log(`[Browser] \u2705 ${result.success ? "Success" : "Failed"} in ${elapsed}ms | steps=${result.stepsTaken ?? 0} recordingId=${result.recordingId ?? "none"}`);
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
+        return {
+          success: false,
+          error: `Cannot connect to browser worker at ${apiUrl}. Ensure the service is running and accessible. For local dev, set MORPH_ENVIRONMENT=DEV.`
+        };
+      }
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+    return {
+      success: false,
+      error: String(error)
+    };
+  }
 }
-async function getTaskStatus(taskId, config) {
+async function getRecording(recordingId, config = {}) {
   const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
   const debug = config.debug || false;
-  if (debug) console.log(`[Browser] getTaskStatus: ${taskId}`);
-  const headers = {};
-  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
-  const response = await fetch(`${apiUrl}/tasks/${taskId}`, {
+  if (!config.apiKey) {
+    throw new Error("API key required for getRecording");
+  }
+  if (debug) console.log(`[Browser] getRecording: ${recordingId}`);
+  const response = await fetch(`${apiUrl}/recordings/${recordingId}`, {
     method: "GET",
-    headers
+    headers: { "Authorization": `Bearer ${config.apiKey}` }
   });
   if (!response.ok) {
     const errorText = await response.text().catch(() => response.statusText);
-    if (debug) console.error(`[Browser] getTaskStatus error: ${response.status} - ${errorText}`);
+    if (debug) console.error(`[Browser] getRecording error: ${response.status} - ${errorText}`);
     throw new Error(`HTTP ${response.status}: ${errorText}`);
   }
-  const result = mapTaskResult(await response.json());
-  if (debug) console.log(`[Browser] Task status: ${result.status}`);
-  return result;
-}
-function generateLiveUrl(taskId, config) {
-  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
-  const baseUrl = apiUrl.replace("/api", "");
-  return `${baseUrl}/tasks/${taskId}/live`;
+  const data = mapRecordingStatus(await response.json());
+  if (debug) console.log(`[Browser] Recording status: ${data.status}`);
+  return {
+    ...data,
+    getWebp: (options) => getWebp(recordingId, config, options),
+    getErrors: () => getErrors(recordingId, config)
+  };
 }
-async function pollTaskUntilComplete(taskId, config, pollConfig = {}) {
-  const interval = pollConfig.interval ?? 2e3;
-  const timeout = pollConfig.timeout ?? 3e5;
+async function waitForRecording(recordingId, config = {}, options = {}) {
+  const timeout = options.timeout ?? 6e4;
+  const pollInterval = options.pollInterval ?? 2e3;
   const startTime = Date.now();
   while (Date.now() - startTime < timeout) {
-    const status = await getTaskStatus(taskId, config);
-    if (status.status === "completed" || status.status === "failed") {
+    const status = await getRecording(recordingId, config);
+    if (status.status === "COMPLETED" || status.status === "ERROR") {
+      return status;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+  }
+  throw new Error(`Recording timeout after ${timeout}ms - status still pending`);
+}
+async function executeWithRecording(input, config = {}) {
+  const taskResult = await executeBrowserTask(input, config);
+  if (taskResult.recordingId) {
+    try {
+      const recording = await waitForRecording(
+        taskResult.recordingId,
+        config,
+        { timeout: 6e4, pollInterval: 2e3 }
+      );
+      return {
+        ...taskResult,
+        recording
+      };
+    } catch (error) {
+      const errorRecording = {
+        id: taskResult.recordingId,
+        status: "ERROR",
+        error: error instanceof Error ? error.message : String(error),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        getWebp: (options) => getWebp(taskResult.recordingId, config, options),
+        getErrors: () => getErrors(taskResult.recordingId, config)
+      };
+      return {
+        ...taskResult,
+        recording: errorRecording
+      };
+    }
+  }
+  return taskResult;
+}
+async function getErrors(recordingId, config = {}) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const debug = config.debug || false;
+  if (!config.apiKey) {
+    throw new Error("API key required for getErrors");
+  }
+  if (debug) console.log(`[Browser] getErrors: ${recordingId}`);
+  const response = await fetch(`${apiUrl}/recordings/${recordingId}/errors`, {
+    method: "GET",
+    headers: { "Authorization": `Bearer ${config.apiKey}` }
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    if (debug) console.error(`[Browser] getErrors error: ${response.status} - ${errorText}`);
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const errors = mapErrorsResponse(await response.json());
+  if (debug) console.log(`[Browser] Found ${errors.totalErrors} errors`);
+  return errors;
+}
+function stringifyStructuredOutput(schema) {
+  try {
+    return JSON.stringify({
+      type: "object",
+      description: "Zod schema definition (Zod v3)",
+      zodDef: schema._def
+    });
+  } catch (error) {
+    console.warn("[Browser] Failed to serialize Zod schema:", error);
+    return JSON.stringify({
+      type: "object",
+      description: "Schema serialization failed"
+    });
+  }
+}
+function parseStructuredTaskOutput(result, schema) {
+  if (!result.output) {
+    return { ...result, parsed: null };
+  }
+  try {
+    const parsed = JSON.parse(result.output);
+    const validated = schema.parse(parsed);
+    return { ...result, parsed: validated };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return { ...result, parsed: null };
+    }
+    throw error;
+  }
+}
+function mapTaskResult(api) {
+  if (!api || typeof api !== "object") {
+    return api;
+  }
+  return {
+    success: api.success,
+    result: api.result,
+    error: api.error,
+    stepsTaken: api.steps_taken,
+    executionTimeMs: api.execution_time_ms,
+    urls: api.urls,
+    actionNames: api.action_names,
+    errors: api.errors,
+    modelActions: api.model_actions,
+    isDone: api.is_done,
+    actionHistory: api.action_history,
+    actionResults: api.action_results,
+    hasErrors: api.has_errors,
+    numberOfSteps: api.number_of_steps,
+    judgement: api.judgement,
+    isValidated: api.is_validated,
+    replayId: api.replay_id,
+    replayUrl: api.replay_url,
+    recordingId: api.recording_id,
+    recordingStatus: api.recording_status,
+    taskId: api.task_id,
+    status: api.status,
+    output: api.output,
+    debugUrl: api.debug_url
+  };
+}
+function mapRecordingStatus(api) {
+  return {
+    id: api.id,
+    status: api.status,
+    replayUrl: api.replay_url,
+    networkUrl: api.network_url,
+    consoleUrl: api.console_url,
+    videoUrl: api.video_url,
+    result: api.result,
+    totalEvents: api.total_events,
+    fileSize: api.file_size,
+    duration: api.duration,
+    error: api.error,
+    createdAt: api.created_at
+  };
+}
+function mapBrowserError(api) {
+  return {
+    type: api.type,
+    message: api.message,
+    url: api.url,
+    timestamp: api.timestamp,
+    screenshotUrl: api.screenshot_url,
+    capturedAt: api.captured_at,
+    status: api.status
+  };
+}
+function mapErrorsResponse(api) {
+  return {
+    recordingId: api.recording_id,
+    totalErrors: api.total_errors,
+    errors: Array.isArray(api.errors) ? api.errors.map(mapBrowserError) : []
+  };
+}
+function mapWebpResponse(api) {
+  return {
+    webpUrl: api.webp_url,
+    cached: api.cached,
+    width: api.width,
+    fps: api.fps,
+    maxDuration: api.max_duration,
+    fileSize: api.file_size,
+    maxSizeMb: api.max_size_mb,
+    budgetMet: api.budget_met,
+    qualityUsed: api.quality_used,
+    attempts: api.attempts
+  };
+}
+async function getTaskStatus(taskId, config) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const debug = config.debug || false;
+  if (debug) console.log(`[Browser] getTaskStatus: ${taskId}`);
+  const headers = {};
+  if (config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
+  const response = await fetch(`${apiUrl}/tasks/${taskId}`, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => response.statusText);
+    if (debug) console.error(`[Browser] getTaskStatus error: ${response.status} - ${errorText}`);
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+  const result = mapTaskResult(await response.json());
+  if (debug) console.log(`[Browser] Task status: ${result.status}`);
+  return result;
+}
+function generateLiveUrl(taskId, config) {
+  const apiUrl = config.apiUrl || DEFAULT_CONFIG2.apiUrl;
+  const baseUrl = apiUrl.replace("/api", "");
+  return `${baseUrl}/tasks/${taskId}/live`;
+}
+async function pollTaskUntilComplete(taskId, config, pollConfig = {}) {
+  const interval = pollConfig.interval ?? 2e3;
+  const timeout = pollConfig.timeout ?? 3e5;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    const status = await getTaskStatus(taskId, config);
+    if (status.status === "completed" || status.status === "failed") {
       return status;
     }
     await new Promise((resolve2) => setTimeout(resolve2, interval));
@@ -1690,103 +2259,8 @@ async function checkHealth(config = {}) {
   }
 }
 
-// tools/warp_grep/agent/config.ts
-var parseEnvTimeout = (envValue, defaultMs) => {
-  if (!envValue) return defaultMs;
-  const parsed = parseInt(envValue, 10);
-  return isNaN(parsed) || parsed <= 0 ? defaultMs : parsed;
-};
-var AGENT_CONFIG = {
-  MAX_TURNS: 4,
-  /** Default timeout for model calls. Can be overridden via MORPH_WARP_GREP_TIMEOUT env var (in ms) */
-  TIMEOUT_MS: parseEnvTimeout(process.env.MORPH_WARP_GREP_TIMEOUT, 3e4),
-  MAX_CONTEXT_CHARS: 54e4,
-  MAX_OUTPUT_LINES: 200,
-  MAX_READ_LINES: 800,
-  MAX_LIST_DEPTH: 3,
-  LIST_TIMEOUT_MS: 2e3
-};
-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-v1";
+// tools/warp_grep/agent/runner.ts
+init_config();
 
 // 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 search_string.
@@ -2302,6 +2776,7 @@ 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;
@@ -2476,6 +2951,7 @@ function formatAgentToolOutput(toolName, args, output, options = {}) {
 
 // tools/warp_grep/agent/helpers.ts
 var import_path2 = __toESM(require("path"), 1);
+init_config();
 var TRUNCATED_MARKER = "[truncated for context limit]";
 function formatTurnMessage(turnsUsed, maxTurns) {
   const turnsRemaining = maxTurns - turnsUsed;
@@ -2558,9 +3034,9 @@ function enforceContextLimit(messages, maxChars = AGENT_CONFIG.MAX_CONTEXT_CHARS
 var import_openai = __toESM(require("openai"), 1);
 var import_path3 = __toESM(require("path"), 1);
 var parser = new LLMResponseParser();
-var DEFAULT_API_URL2 = "https://api.morphllm.com";
+var DEFAULT_API_URL3 = "https://api.morphllm.com";
 async function callModel(messages, model, options = {}) {
-  const baseUrl = options.morphApiUrl || DEFAULT_API_URL2;
+  const baseUrl = options.morphApiUrl || DEFAULT_API_URL3;
   const apiKey = options.morphApiKey || process.env.MORPH_API_KEY || "";
   const timeoutMs = options.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
   const client = new import_openai.default({
@@ -2669,624 +3145,225 @@ async function runWarpGrep(config) {
         toolRead(provider, args).then(
           (p) => formatAgentToolOutput("read", args, p, { isError: false }),
           (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 ?? [];
-      finishMeta = { files };
-      terminationReason = "completed";
-      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}]`];
-      }
-    }
-  );
-  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
-  if (fileReadErrors.length > 0) {
-    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
-  }
-  timings.total_ms = Date.now() - totalStart;
-  return {
-    terminationReason: "completed",
-    messages,
-    finish: { payload, metadata: finishMeta, resolved },
-    timings
-  };
-}
-async function* runWarpGrepStreaming(config) {
-  const totalStart = Date.now();
-  const timeoutMs = config.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
-  const timings = { turns: [], timeout_ms: timeoutMs };
-  const repoRoot = import_path3.default.resolve(config.repoRoot || process.cwd());
-  const messages = [];
-  messages.push({ role: "system", content: getSystemPrompt() });
-  const initialStateStart = Date.now();
-  const initialState = await buildInitialState(repoRoot, config.query, config.provider);
-  timings.initial_state_ms = Date.now() - initialStateStart;
-  messages.push({ role: "user", content: initialState });
-  const maxTurns = AGENT_CONFIG.MAX_TURNS;
-  const model = config.model || DEFAULT_MODEL;
-  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
-    }).catch((e) => {
-      errors.push({ message: e instanceof Error ? e.message : String(e) });
-      return "";
-    });
-    turnMetrics.morph_api_ms = Date.now() - modelCallStart;
-    if (!assistantContent) {
-      timings.turns.push(turnMetrics);
-      break;
-    }
-    messages.push({ role: "assistant", content: assistantContent });
-    const toolCalls = parser.parse(assistantContent);
-    if (toolCalls.length === 0) {
-      errors.push({ message: "No tool calls produced by the model. Your MCP is likely out of date! Update it by running: rm -rf ~/.npm/_npx && npm cache clean --force && npx -y @morphllm/morphmcp@latest" });
-      terminationReason = "terminated";
-      timings.turns.push(turnMetrics);
-      break;
-    }
-    yield {
-      turn,
-      toolCalls: toolCalls.map((c) => ({
-        name: c.name,
-        arguments: c.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, { isError: false }),
-          (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, { isError: false }),
-          (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, { isError: false }),
-          (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 ?? [];
-      finishMeta = { files };
-      terminationReason = "completed";
-      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}]`];
-      }
-    }
-  );
-  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
-  if (fileReadErrors.length > 0) {
-    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
-  }
-  timings.total_ms = Date.now() - totalStart;
-  return {
-    terminationReason: "completed",
-    messages,
-    finish: { payload, metadata: finishMeta, resolved },
-    timings
-  };
-}
-
-// tools/warp_grep/providers/local.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_path5 = __toESM(require("path"), 1);
-
-// tools/warp_grep/utils/ripgrep.ts
-var import_child_process = require("child_process");
-var import_ripgrep = require("@vscode/ripgrep");
-var resolvedRgPath = null;
-var rgPathChecked = false;
-function spawnRg(rgBinary, args, opts) {
-  return new Promise((resolve2) => {
-    const child = (0, import_child_process.spawn)(rgBinary, 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.", exitCode: -1 });
-    });
-  });
-}
-function isBinaryFailure(result) {
-  if (result.exitCode === -1) return true;
-  if (result.stderr.includes("jemalloc") || result.stderr.includes("Unsupported system page size")) return true;
-  if (result.exitCode === 134) return true;
-  return false;
-}
-async function runRipgrep(args, opts) {
-  if (rgPathChecked && resolvedRgPath) {
-    return spawnRg(resolvedRgPath, args, opts);
-  }
-  if (!rgPathChecked) {
-    const result = await spawnRg(import_ripgrep.rgPath, args, opts);
-    if (!isBinaryFailure(result)) {
-      resolvedRgPath = import_ripgrep.rgPath;
-      rgPathChecked = true;
-      return result;
-    }
-    const fallbackResult = await spawnRg("rg", args, opts);
-    if (!isBinaryFailure(fallbackResult)) {
-      resolvedRgPath = "rg";
-      rgPathChecked = true;
-      return fallbackResult;
-    }
-    rgPathChecked = true;
-    return {
-      stdout: "",
-      stderr: "Failed to spawn ripgrep. Neither bundled nor system rg is available.",
-      exitCode: -1
-    };
-  }
-  return {
-    stdout: "",
-    stderr: "Failed to spawn ripgrep. Neither bundled nor system rg is available.",
-    exitCode: -1
-  };
-}
-
-// tools/warp_grep/utils/paths.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path4 = __toESM(require("path"), 1);
-function resolveUnderRepo(repoRoot, 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_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_path4.default.relative(import_path4.default.resolve(repoRoot), import_path4.default.resolve(absPath));
-}
-function isSymlink(p) {
-  try {
-    const st = import_fs.default.lstatSync(p);
-    return st.isSymbolicLink();
-  } catch {
-    return false;
-  }
-}
-function fixPathRepetition(fullPath) {
-  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++) {
-      const first = segments.slice(i, i + len);
-      const second = segments.slice(i + len, i + 2 * len);
-      if (first.every((seg, idx) => seg === second[idx])) {
-        const fixed = [...segments.slice(0, i), ...segments.slice(i + len)];
-        return import_path4.default.sep + fixed.join(import_path4.default.sep);
-      }
-    }
-  }
-  return null;
-}
-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_promises2 = __toESM(require("fs/promises"), 1);
-async function readAllLines(filePath) {
-  const content = await import_promises2.default.readFile(filePath, "utf8");
-  return content.split(/\r?\n/);
-}
-
-// tools/warp_grep/providers/local.ts
-var SKIP_NAMES = /* @__PURE__ */ new Set([
-  // Version control
-  ".git",
-  ".svn",
-  ".hg",
-  ".bzr",
-  // Dependencies
-  "node_modules",
-  "bower_components",
-  ".pnpm",
-  ".yarn",
-  "vendor",
-  "Pods",
-  ".bundle",
-  // Python
-  "__pycache__",
-  ".pytest_cache",
-  ".mypy_cache",
-  ".ruff_cache",
-  ".venv",
-  "venv",
-  ".tox",
-  ".nox",
-  ".eggs",
-  // Build outputs
-  "dist",
-  "build",
-  "out",
-  "output",
-  "target",
-  "_build",
-  ".next",
-  ".nuxt",
-  ".output",
-  ".vercel",
-  ".netlify",
-  // Cache
-  ".cache",
-  ".parcel-cache",
-  ".turbo",
-  ".nx",
-  ".gradle",
-  // IDE
-  ".idea",
-  ".vscode",
-  ".vs",
-  // Coverage
-  "coverage",
-  ".coverage",
-  "htmlcov",
-  ".nyc_output",
-  // Temp
-  "tmp",
-  "temp",
-  ".tmp",
-  ".temp",
-  // Lock files
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml",
-  "bun.lockb",
-  "Cargo.lock",
-  "Gemfile.lock",
-  "poetry.lock"
-]);
-var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".min.js",
-  ".min.css",
-  ".bundle.js",
-  ".wasm",
-  ".so",
-  ".dll",
-  ".pyc",
-  ".map",
-  ".js.map"
-]);
-function shouldSkip(name) {
-  if (SKIP_NAMES.has(name)) return true;
-  if (name.startsWith(".")) return true;
-  for (const ext of SKIP_EXTENSIONS) {
-    if (name.endsWith(ext)) return true;
-  }
-  return false;
-}
-var LocalRipgrepProvider = class {
-  constructor(repoRoot, excludes = DEFAULT_EXCLUDES) {
-    this.repoRoot = repoRoot;
-    this.excludes = excludes;
-  }
-  async grep(params) {
-    let abs;
-    try {
-      abs = resolveUnderRepo(this.repoRoot, params.path);
-    } catch (err) {
-      return {
-        lines: [],
-        error: `[PATH ERROR] ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-    const stat = await import_promises3.default.stat(abs).catch(() => null);
-    if (!stat) return { lines: [] };
-    const targetArg = abs === import_path5.default.resolve(this.repoRoot) ? "." : toRepoRelative(this.repoRoot, abs);
-    const args = [
-      "--no-config",
-      "--no-heading",
-      "--with-filename",
-      "--line-number",
-      "--color=never",
-      "--trim",
-      "--max-columns=400",
-      "-C",
-      "1",
-      ...params.glob ? ["--glob", params.glob] : [],
-      ...this.excludes.flatMap((e) => ["-g", `!${e}`]),
-      params.pattern,
-      targetArg || "."
-    ];
-    const res = await runRipgrep(args, { cwd: this.repoRoot });
-    if (res.exitCode === -1) {
-      return {
-        lines: [],
-        error: `[RIPGREP NOT AVAILABLE] ripgrep (rg) is required but failed to execute. Please install it:
-  \u2022 macOS: brew install ripgrep
-  \u2022 Ubuntu/Debian: apt install ripgrep
-  \u2022 Windows: choco install ripgrep
-  \u2022 Or visit: https://github.com/BurntSushi/ripgrep#installation
-Exit code: ${res.exitCode}${res.stderr ? `
-Details: ${res.stderr}` : ""}`
-      };
+        )
+      );
     }
-    if (res.exitCode !== 0 && res.exitCode !== 1) {
-      return {
-        lines: [],
-        error: `[RIPGREP ERROR] grep failed with exit code ${res.exitCode}${res.stderr ? `: ${res.stderr}` : ""}`
-      };
+    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);
     }
-    const lines = (res.stdout || "").trim().split(/\r?\n/).filter((l) => l.length > 0);
-    if (lines.length > AGENT_CONFIG.MAX_OUTPUT_LINES) {
-      return {
-        lines: [],
-        error: "query not specific enough, tool tried to return too much context and failed"
-      };
+    if (formatted.length > 0) {
+      const turnMessage = formatTurnMessage(turn, maxTurns);
+      const contextBudget = calculateContextBudget(messages);
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
     }
-    return { lines };
-  }
-  async read(params) {
-    let abs;
-    try {
-      abs = resolveUnderRepo(this.repoRoot, params.path);
-    } catch (err) {
-      return {
-        lines: [],
-        error: `[PATH ERROR] ${err instanceof Error ? err.message : String(err)}`
-      };
+    timings.turns.push(turnMetrics);
+    if (finishCalls.length) {
+      const fc = finishCalls[0];
+      const files = fc.arguments?.files ?? [];
+      finishMeta = { files };
+      terminationReason = "completed";
+      break;
     }
-    let stat = await import_promises3.default.stat(abs).catch(() => null);
-    if (!stat || !stat.isFile()) {
-      const fixedPath = fixPathRepetition(abs);
-      if (fixedPath) {
-        const fixedStat = await import_promises3.default.stat(fixedPath).catch(() => null);
-        if (fixedStat?.isFile()) {
-          abs = fixedPath;
-          stat = fixedStat;
-        }
+  }
+  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}]`];
       }
     }
-    if (!stat || !stat.isFile()) {
-      return {
-        lines: [],
-        error: `[FILE NOT FOUND] You tried to read "${params.path}" but there is no file at this path. Double-check the path exists and is spelled correctly.`
-      };
+  );
+  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
+  if (fileReadErrors.length > 0) {
+    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
+  }
+  timings.total_ms = Date.now() - totalStart;
+  return {
+    terminationReason: "completed",
+    messages,
+    finish: { payload, metadata: finishMeta, resolved },
+    timings
+  };
+}
+async function* runWarpGrepStreaming(config) {
+  const totalStart = Date.now();
+  const timeoutMs = config.timeout ?? AGENT_CONFIG.TIMEOUT_MS;
+  const timings = { turns: [], timeout_ms: timeoutMs };
+  const repoRoot = import_path3.default.resolve(config.repoRoot || process.cwd());
+  const messages = [];
+  messages.push({ role: "system", content: getSystemPrompt() });
+  const initialStateStart = Date.now();
+  const initialState = await buildInitialState(repoRoot, config.query, config.provider);
+  timings.initial_state_ms = Date.now() - initialStateStart;
+  messages.push({ role: "user", content: initialState });
+  const maxTurns = AGENT_CONFIG.MAX_TURNS;
+  const model = config.model || DEFAULT_MODEL;
+  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
+    }).catch((e) => {
+      errors.push({ message: e instanceof Error ? e.message : String(e) });
+      return "";
+    });
+    turnMetrics.morph_api_ms = Date.now() - modelCallStart;
+    if (!assistantContent) {
+      timings.turns.push(turnMetrics);
+      break;
     }
-    if (isSymlink(abs)) {
-      return {
-        lines: [],
-        error: `[SYMLINK] You tried to read "${params.path}" but this is a symlink. Try reading the actual file it points to instead.`
-      };
+    messages.push({ role: "assistant", content: assistantContent });
+    const toolCalls = parser.parse(assistantContent);
+    if (toolCalls.length === 0) {
+      errors.push({ message: "No tool calls produced by the model. 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;
     }
-    if (!isTextualFile(abs)) {
-      return {
-        lines: [],
-        error: `[UNREADABLE FILE] You tried to read "${params.path}" but this file is either too large or not a text file, so it cannot be read. Try a different file.`
-      };
+    yield {
+      turn,
+      toolCalls: toolCalls.map((c) => ({
+        name: c.name,
+        arguments: c.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);
     }
-    let lines;
-    try {
-      lines = await readAllLines(abs);
-    } catch (err) {
-      return {
-        lines: [],
-        error: `[READ ERROR] Failed to read "${params.path}": ${err instanceof Error ? err.message : String(err)}`
-      };
+    const allPromises = [];
+    for (const c of grepCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolGrep(provider, args).then(
+          ({ output }) => formatAgentToolOutput("grep", args, output, { isError: false }),
+          (err) => formatAgentToolOutput("grep", args, String(err), { isError: true })
+        )
+      );
     }
-    const total = lines.length;
-    const rawStart = params.start;
-    const rawEnd = params.end;
-    let s = 1;
-    let e = total;
-    const startValid = rawStart === void 0 || Number.isFinite(rawStart) && rawStart > 0;
-    const endValid = rawEnd === void 0 || Number.isFinite(rawEnd) && rawEnd > 0;
-    if (startValid && endValid) {
-      s = rawStart ?? 1;
-      e = Math.min(rawEnd ?? total, total);
-      if (s > total && total > 0 || s > e) {
-        s = 1;
-        e = total;
-      }
+    for (const c of listDirCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolListDirectory(provider, args).then(
+          (p) => formatAgentToolOutput("list_directory", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("list_directory", args, String(err), { isError: true })
+        )
+      );
     }
-    const out = [];
-    for (let i = s; i <= e; i += 1) {
-      const content = lines[i - 1] ?? "";
-      out.push(`${i}|${content}`);
+    for (const c of readCalls) {
+      const args = c.arguments ?? {};
+      allPromises.push(
+        toolRead(provider, args).then(
+          (p) => formatAgentToolOutput("read", args, p, { isError: false }),
+          (err) => formatAgentToolOutput("read", args, String(err), { isError: true })
+        )
+      );
     }
-    if (out.length > AGENT_CONFIG.MAX_READ_LINES) {
-      const truncated = out.slice(0, AGENT_CONFIG.MAX_READ_LINES);
-      truncated.push(`... [truncated: showing ${AGENT_CONFIG.MAX_READ_LINES} of ${out.length} lines]`);
-      return { lines: truncated };
+    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);
     }
-    return { lines: out };
-  }
-  async listDirectory(params) {
-    let abs;
-    try {
-      abs = resolveUnderRepo(this.repoRoot, params.path);
-    } catch {
-      return [];
+    if (formatted.length > 0) {
+      const turnMessage = formatTurnMessage(turn, maxTurns);
+      const contextBudget = calculateContextBudget(messages);
+      messages.push({ role: "user", content: formatted.join("\n") + turnMessage + "\n" + contextBudget });
     }
-    const stat = await import_promises3.default.stat(abs).catch(() => null);
-    if (!stat || !stat.isDirectory()) {
-      return [];
+    timings.turns.push(turnMetrics);
+    if (finishCalls.length) {
+      const fc = finishCalls[0];
+      const files = fc.arguments?.files ?? [];
+      finishMeta = { files };
+      terminationReason = "completed";
+      break;
     }
-    const maxResults = params.maxResults ?? AGENT_CONFIG.MAX_OUTPUT_LINES;
-    const maxDepth = params.maxDepth ?? AGENT_CONFIG.MAX_LIST_DEPTH;
-    const regex = params.pattern ? new RegExp(params.pattern) : null;
-    const repoRoot = this.repoRoot;
-    const results = [];
-    let timedOut = false;
-    const startTime = Date.now();
-    async function walk(dir, depth) {
-      if (Date.now() - startTime > AGENT_CONFIG.LIST_TIMEOUT_MS) {
-        timedOut = true;
-        return;
-      }
-      if (depth > maxDepth || results.length >= maxResults) return;
-      const entries = await import_promises3.default.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (timedOut || results.length >= maxResults) break;
-        if (shouldSkip(entry.name)) continue;
-        if (regex && !regex.test(entry.name)) continue;
-        const full = import_path5.default.join(dir, entry.name);
-        const isDir = entry.isDirectory();
-        results.push({
-          name: entry.name,
-          path: toRepoRelative(repoRoot, full),
-          type: isDir ? "dir" : "file",
-          depth
+  }
+  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;
         });
-        if (isDir) {
-          await walk(full, depth + 1);
-        }
+      } 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}]`];
       }
     }
-    await walk(abs, 0);
-    return results;
+  );
+  timings.finish_resolution_ms = Date.now() - finishResolutionStart;
+  if (fileReadErrors.length > 0) {
+    errors.push(...fileReadErrors.map((e) => ({ message: `File read error: ${e.path} - ${e.error}` })));
   }
-};
+  timings.total_ms = Date.now() - totalStart;
+  return {
+    terminationReason: "completed",
+    messages,
+    finish: { payload, metadata: finishMeta, resolved },
+    timings
+  };
+}
 
 // tools/warp_grep/providers/remote.ts
-var SKIP_NAMES2 = /* @__PURE__ */ new Set([
+init_config();
+var SKIP_NAMES = /* @__PURE__ */ new Set([
   // Version control
   ".git",
   ".svn",
@@ -3351,7 +3428,7 @@ var SKIP_NAMES2 = /* @__PURE__ */ new Set([
   "Gemfile.lock",
   "poetry.lock"
 ]);
-var SKIP_EXTENSIONS2 = /* @__PURE__ */ new Set([
+var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
   ".min.js",
   ".min.css",
   ".bundle.js",
@@ -3362,10 +3439,10 @@ var SKIP_EXTENSIONS2 = /* @__PURE__ */ new Set([
   ".map",
   ".js.map"
 ]);
-function shouldSkip2(name) {
-  if (SKIP_NAMES2.has(name)) return true;
+function shouldSkip(name) {
+  if (SKIP_NAMES.has(name)) return true;
   if (name.startsWith(".")) return true;
-  for (const ext of SKIP_EXTENSIONS2) {
+  for (const ext of SKIP_EXTENSIONS) {
     if (name.endsWith(ext)) return true;
   }
   return false;
@@ -3441,7 +3518,7 @@ var RemoteCommandsProvider = class {
       for (const fullPath of paths) {
         if (fullPath === params.path || fullPath === this.repoRoot) continue;
         const name = fullPath.split("/").pop() || "";
-        if (shouldSkip2(name)) continue;
+        if (shouldSkip(name)) continue;
         if (regex && !regex.test(name)) continue;
         let relativePath = fullPath;
         if (fullPath.startsWith(this.repoRoot)) {
@@ -3466,6 +3543,10 @@ var RemoteCommandsProvider = class {
 };
 
 // tools/warp_grep/client.ts
+async function getLocalProvider(repoRoot, excludes) {
+  const { LocalRipgrepProvider: LocalRipgrepProvider2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+  return new LocalRipgrepProvider2(repoRoot, excludes);
+}
 var WarpGrepClient = class {
   config;
   constructor(config = {}) {
@@ -3498,7 +3579,7 @@ var WarpGrepClient = class {
 };
 async function executeToolCall(input, config) {
   const parsed = typeof input === "string" ? JSON.parse(input) : input;
-  const provider = config.remoteCommands ? new RemoteCommandsProvider(config.repoRoot, config.remoteCommands) : config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const provider = config.remoteCommands ? new RemoteCommandsProvider(config.repoRoot, config.remoteCommands) : config.provider ?? await getLocalProvider(config.repoRoot, config.excludes);
   const result = await runWarpGrep({
     query: parsed.query,
     repoRoot: config.repoRoot,
@@ -3534,7 +3615,7 @@ function processAgentResult(result) {
 }
 async function* executeToolCallStreaming(input, config) {
   const parsed = typeof input === "string" ? JSON.parse(input) : input;
-  const provider = config.remoteCommands ? new RemoteCommandsProvider(config.repoRoot, config.remoteCommands) : config.provider ?? new LocalRipgrepProvider(config.repoRoot, config.excludes);
+  const provider = config.remoteCommands ? new RemoteCommandsProvider(config.repoRoot, config.remoteCommands) : config.provider ?? await getLocalProvider(config.repoRoot, config.excludes);
   const generator = runWarpGrepStreaming({
     query: parsed.query,
     repoRoot: config.repoRoot,
@@ -4126,6 +4207,7 @@ var import_isomorphic_git2 = __toESM(require("isomorphic-git"), 1);
 var import_node2 = __toESM(require("isomorphic-git/http/node"), 1);
 
 // modelrouter/core.ts
+init_resilience();
 var DEFAULT_CONFIG3 = {
   apiUrl: "https://api.morphllm.com",
   timeout: 5e3,
@@ -4150,7 +4232,7 @@ var BaseRouter = class {
    */
   async selectModel(input) {
     const mode = input.mode || "balanced";
-    const apiKey = this.config.apiKey || process.env.MORPH_API_KEY;
+    const apiKey = this.config.apiKey || (typeof process !== "undefined" ? process.env?.MORPH_API_KEY : void 0);
     if (!apiKey) {
       throw new Error(
         "Morph API key is required. Set MORPH_API_KEY environment variable or pass apiKey in config."
@@ -4261,7 +4343,7 @@ var RawRouter = class extends BaseRouter {
    */
   async classify(input) {
     const mode = input.mode || "balanced";
-    const apiKey = this.config.apiKey || process.env.MORPH_API_KEY;
+    const apiKey = this.config.apiKey || (typeof process !== "undefined" ? process.env?.MORPH_API_KEY : void 0);
     if (!apiKey) {
       throw new Error(
         "Morph API key is required. Set MORPH_API_KEY environment variable or pass apiKey in config."
@@ -5060,6 +5142,17 @@ var MorphClient = class {
 
 // tools/warp_grep/index.ts
 var import_zod4 = require("zod");
+
+// tools/warp_grep/providers/index.ts
+init_local();
+
+// tools/warp_grep/index.ts
+init_paths();
+
+// tools/warp_grep/agent/index.ts
+init_config();
+
+// tools/warp_grep/index.ts
 var warpGrepInputSchema = import_zod4.z.object({
   query: import_zod4.z.string().describe("Free-form repository question")
 });