amai 0.0.21 → 0.0.22

package/dist/server.js

@@ -1,1856 +1,23 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import WebSocket2 from 'ws';
-import { z } from 'zod';
-import path10 from 'path';
-import fs8, { readdirSync } from 'fs';
-import * as fsp from 'fs/promises';
-import fsp__default, { mkdir, unlink } from 'fs/promises';
-import os3 from 'os';
-import pc3 from 'picocolors';
-import { Hono } from 'hono';
-import { serve } from '@hono/node-server';
-import { cors } from 'hono/cors';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-
-var MUTATING_TOOLS = /* @__PURE__ */ new Set([
-  "editFile",
-  "deleteFile",
-  "stringReplace",
-  "bash"
-]);
-function isMutatingTool(toolName) {
-  return MUTATING_TOOLS.has(toolName);
-}
-function isPathWithinProject(filePath, projectCwd) {
-  try {
-    const resolvedCwd = safeRealpath(projectCwd);
-    const resolved = path10.resolve(resolvedCwd, filePath);
-    const resolvedTarget = safeRealpath(resolved);
-    const rel = path10.relative(resolvedCwd, resolvedTarget);
-    if (rel.startsWith("..") || path10.isAbsolute(rel)) {
-      return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-function safeRealpath(p) {
-  try {
-    return fs8.realpathSync(p);
-  } catch {
-    const parent = path10.dirname(p);
-    try {
-      const realParent = fs8.realpathSync(parent);
-      return path10.join(realParent, path10.basename(p));
-    } catch {
-      return path10.resolve(p);
-    }
-  }
-}
-function validatePath(filePath, projectCwd) {
-  if (!projectCwd) {
-    return {
-      valid: false,
-      error: "ACCESS_DENIED: No project context provided"
-    };
-  }
-  try {
-    if (!isPathWithinProject(filePath, projectCwd)) {
-      return {
-        valid: false,
-        error: `ACCESS_DENIED: Path "${filePath}" is outside project directory "${projectCwd}"`
-      };
-    }
-    const resolvedCwd = safeRealpath(projectCwd);
-    const resolvedPath = path10.resolve(resolvedCwd, filePath);
-    return {
-      valid: true,
-      resolvedPath
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      error: `ACCESS_DENIED: Invalid path "${filePath}"`
-    };
-  }
-}
-function resolveProjectPath(filePath, projectCwd) {
-  return path10.resolve(projectCwd, filePath);
-}
-function requireProjectCwd(toolName, projectCwd) {
-  if (!projectCwd && isMutatingTool(toolName)) {
-    return {
-      allowed: false,
-      error: `ACCESS_DENIED: Tool "${toolName}" requires a project context (projectCwd) but none was provided`
-    };
-  }
-  return { allowed: true };
-}
-
-// src/tools/read-file.ts
-var MAX_FILE_SIZE = 10 * 1024 * 1024;
-var MAX_LINES_RETURNED = 2e3;
-var MAX_LINE_LENGTH = 2e3;
-var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
-var MAX_BYTES = 50 * 1024;
-var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".zip",
-  ".tar",
-  ".gz",
-  ".exe",
-  ".dll",
-  ".so",
-  ".class",
-  ".jar",
-  ".war",
-  ".7z",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".odt",
-  ".ods",
-  ".odp",
-  ".bin",
-  ".dat",
-  ".obj",
-  ".o",
-  ".a",
-  ".lib",
-  ".wasm",
-  ".pyc",
-  ".pyo",
-  ".ico",
-  ".bmp",
-  ".ttf",
-  ".woff",
-  ".woff2",
-  ".eot",
-  ".mp3",
-  ".mp4",
-  ".avi",
-  ".mov",
-  ".flv"
-]);
-async function isBinaryFile(filepath, fileSize) {
-  const ext = path10.extname(filepath).toLowerCase();
-  if (BINARY_EXTENSIONS.has(ext)) return true;
-  if (fileSize === 0) return false;
-  try {
-    const fh = await fsp.open(filepath, "r");
-    try {
-      const sampleSize = Math.min(4096, fileSize);
-      const bytes = Buffer.alloc(sampleSize);
-      const result = await fh.read(bytes, 0, sampleSize, 0);
-      if (result.bytesRead === 0) return false;
-      let nonPrintableCount = 0;
-      for (let i = 0; i < result.bytesRead; i++) {
-        if (bytes[i] === 0) return true;
-        if (bytes[i] < 9 || bytes[i] > 13 && bytes[i] < 32) {
-          nonPrintableCount++;
-        }
-      }
-      return nonPrintableCount / result.bytesRead > 0.3;
-    } finally {
-      await fh.close();
-    }
-  } catch {
-    return false;
-  }
-}
-async function findSimilarFiles(filepath) {
-  const dir = path10.dirname(filepath);
-  const base = path10.basename(filepath).toLowerCase();
-  try {
-    const entries = await fsp.readdir(dir);
-    return entries.filter(
-      (entry) => entry.toLowerCase().includes(base) || base.includes(entry.toLowerCase())
-    ).map((entry) => path10.join(dir, entry)).slice(0, 3);
-  } catch {
-    return [];
-  }
-}
-z.object({
-  relative_file_path: z.string().describe("The path to the file or directory to read."),
-  should_read_entire_file: z.boolean().describe("Whether to read the entire file.").optional().default(true),
-  start_line_one_indexed: z.number().optional().describe("The one-indexed line number to start reading from (inclusive). Alias: offset."),
-  end_line_one_indexed: z.number().optional().describe("The one-indexed line number to end reading at (inclusive). Alias: offset + limit.")
-});
-async function readFileContent(absolute_file_path, relative_file_path, should_read_entire_file, start_line_one_indexed, end_line_one_indexed) {
-  let stat2;
-  try {
-    stat2 = fs8.statSync(absolute_file_path);
-  } catch {
-    const suggestions = await findSimilarFiles(absolute_file_path);
-    let message = `File not found: ${relative_file_path}`;
-    if (suggestions.length > 0) {
-      message += `
-
-Did you mean one of these?
-${suggestions.join("\n")}`;
-    }
-    return {
-      success: false,
-      message,
-      error: "FILE_NOT_FOUND"
-    };
-  }
-  if (stat2.isDirectory()) {
-    try {
-      const dirents = await fsp.readdir(absolute_file_path, { withFileTypes: true });
-      const entries = await Promise.all(
-        dirents.map(async (dirent) => {
-          if (dirent.isDirectory()) return dirent.name + "/";
-          if (dirent.isSymbolicLink()) {
-            const target = await fsp.stat(path10.join(absolute_file_path, dirent.name)).catch(() => void 0);
-            if (target?.isDirectory()) return dirent.name + "/";
-          }
-          return dirent.name;
-        })
-      );
-      entries.sort((a, b) => a.localeCompare(b));
-      const truncated = entries.length > MAX_LINES_RETURNED;
-      const sliced = entries.slice(0, MAX_LINES_RETURNED);
-      const output = [
-        `<path>${absolute_file_path}</path>`,
-        `<type>directory</type>`,
-        `<entries>`,
-        sliced.join("\n"),
-        truncated ? `
-(Showing ${sliced.length} of ${entries.length} entries)` : `
-(${entries.length} entries)`,
-        `</entries>`
-      ].join("\n");
-      return {
-        success: true,
-        message: `Listed directory: ${relative_file_path} (${entries.length} entries)`,
-        content: output,
-        totalLines: entries.length,
-        truncated
-      };
-    } catch (err) {
-      return {
-        success: false,
-        message: `Failed to list directory: ${relative_file_path}`,
-        error: "READ_ERROR"
-      };
-    }
-  }
-  try {
-    if (stat2.size > MAX_FILE_SIZE) {
-      return {
-        success: false,
-        message: `File too large (${Math.round(stat2.size / 1024 / 1024)}MB). Maximum is ${MAX_FILE_SIZE / 1024 / 1024}MB. Use line ranges to read portions.`,
-        error: "FILE_TOO_LARGE"
-      };
-    }
-    const binary = await isBinaryFile(absolute_file_path, stat2.size);
-    if (binary) {
-      return {
-        success: false,
-        message: `Cannot read binary file: ${relative_file_path}`,
-        error: "BINARY_FILE"
-      };
-    }
-    const fileContent = await Bun.file(absolute_file_path).text();
-    const lines = fileContent.split(/\r?\n/);
-    const totalLines = lines.length;
-    const start = should_read_entire_file ? 0 : (start_line_one_indexed ?? 1) - 1;
-    const end = should_read_entire_file ? Math.min(totalLines, MAX_LINES_RETURNED) : Math.min(end_line_one_indexed ?? totalLines, totalLines);
-    if (start >= totalLines && !(totalLines === 0 && start === 0)) {
-      return {
-        success: false,
-        message: `Offset ${start + 1} is out of range for this file (${totalLines} lines)`,
-        error: "INVALID_LINE_RANGE"
-      };
-    }
-    const outputLines = [];
-    let bytes = 0;
-    let truncatedByBytes = false;
-    let actualEnd = start;
-    for (let i = start; i < end; i++) {
-      let line = lines[i];
-      if (line.length > MAX_LINE_LENGTH) {
-        line = line.substring(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX;
-      }
-      const numberedLine = `${i + 1}: ${line}`;
-      const lineBytes = Buffer.byteLength(numberedLine, "utf-8") + (outputLines.length > 0 ? 1 : 0);
-      if (bytes + lineBytes > MAX_BYTES && outputLines.length > 0) {
-        truncatedByBytes = true;
-        break;
-      }
-      outputLines.push(numberedLine);
-      bytes += lineBytes;
-      actualEnd = i + 1;
-    }
-    const hasMoreLines = actualEnd < totalLines;
-    const truncated = truncatedByBytes || hasMoreLines || should_read_entire_file && totalLines > MAX_LINES_RETURNED;
-    let output = `<path>${absolute_file_path}</path>
-<type>file</type>
-<content>
-`;
-    output += outputLines.join("\n");
-    if (truncatedByBytes) {
-      output += `
-
-(Output capped at ${MAX_BYTES / 1024} KB. Showing lines ${start + 1}-${actualEnd}. Use start_line_one_indexed=${actualEnd + 1} to continue.)`;
-    } else if (hasMoreLines && !should_read_entire_file) {
-      output += `
-
-(Showing lines ${start + 1}-${actualEnd} of ${totalLines}. Use start_line_one_indexed=${actualEnd + 1} to continue.)`;
-    } else {
-      output += `
-
-(End of file - total ${totalLines} lines)`;
-    }
-    output += "\n</content>";
-    return {
-      success: true,
-      message: truncated ? `Read lines ${start + 1}-${actualEnd} of ${totalLines} from: ${relative_file_path} (truncated)` : `Successfully read file: ${relative_file_path} (${totalLines} lines)`,
-      content: output,
-      totalLines,
-      truncated
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to read file: ${relative_file_path}`,
-      error: "READ_ERROR"
-    };
-  }
-}
-var read_file = async function(input, projectCwd) {
-  const { relative_file_path, should_read_entire_file = true, start_line_one_indexed, end_line_one_indexed } = input;
-  try {
-    if (!relative_file_path) {
-      return {
-        success: false,
-        message: "Missing required parameter: relative_file_path",
-        error: "MISSING_TARGET_FILE"
-      };
-    }
-    if (!should_read_entire_file) {
-      if (start_line_one_indexed === void 0 || end_line_one_indexed === void 0) {
-        return {
-          success: false,
-          message: "start_line_one_indexed and end_line_one_indexed are required when should_read_entire_file is false",
-          error: "MISSING_LINE_RANGE"
-        };
-      }
-      if (!Number.isInteger(start_line_one_indexed) || start_line_one_indexed < 1) {
-        return {
-          success: false,
-          message: "start_line_one_indexed must be a positive integer (1-indexed)",
-          error: "INVALID_START_LINE"
-        };
-      }
-      if (!Number.isInteger(end_line_one_indexed) || end_line_one_indexed < 1) {
-        return {
-          success: false,
-          message: "end_line_one_indexed must be a positive integer (1-indexed)",
-          error: "INVALID_END_LINE"
-        };
-      }
-      if (end_line_one_indexed < start_line_one_indexed) {
-        return {
-          success: false,
-          message: "end_line_one_indexed must be greater than or equal to start_line_one_indexed",
-          error: "INVALID_LINE_RANGE"
-        };
-      }
-    }
-    let absolute_file_path;
-    if (projectCwd) {
-      const validation = validatePath(relative_file_path, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
-      }
-      absolute_file_path = validation.resolvedPath;
-    } else {
-      absolute_file_path = path10.resolve(relative_file_path);
-    }
-    return await readFileContent(
-      absolute_file_path,
-      relative_file_path,
-      should_read_entire_file,
-      start_line_one_indexed,
-      end_line_one_indexed
-    );
-  } catch {
-    return {
-      success: false,
-      message: `Failed to read file: ${relative_file_path}`,
-      error: "READ_ERROR"
-    };
-  }
-};
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/base.js
-var Diff = class {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return void 0;
-      } else {
-        return value;
-      }
-    };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = void 0;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = void 0;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
-      }
-      editLength++;
-    };
-    if (callback) {
-      (function exec2() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(void 0);
-          }
-          if (!execEditLength()) {
-            exec2();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
-    }
-  }
-  addToPath(path14, added, removed, oldPosInc, options) {
-    const last = path14.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path14.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path14.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
-    }
-  }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-      }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  }
-  removeEmpty(array) {
-    const ret = [];
-    for (let i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  castInput(value, options) {
-    return value;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
-  }
-  postProcess(changeObjects, options) {
-    return changeObjects;
-  }
-  get useLongestToken() {
-    return false;
-  }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (; componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i) {
-            const oldValue = oldTokens[oldPos + i];
-            return oldValue.length > value2.length ? oldValue : value2;
-          });
-          component.value = this.join(value);
-        } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
-        }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
-      }
-    }
-    return components;
-  }
-};
-
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/line.js
-var LineDiff = class extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  equals(left, right, options) {
-    if (options.ignoreWhitespace) {
-      if (!options.newlineIsToken || !left.includes("\n")) {
-        left = left.trim();
-      }
-      if (!options.newlineIsToken || !right.includes("\n")) {
-        right = right.trim();
-      }
-    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-      if (left.endsWith("\n")) {
-        left = left.slice(0, -1);
-      }
-      if (right.endsWith("\n")) {
-        right = right.slice(0, -1);
-      }
-    }
-    return super.equals(left, right, options);
-  }
-};
-var lineDiff = new LineDiff();
-function diffLines(oldStr, newStr, options) {
-  return lineDiff.diff(oldStr, newStr, options);
-}
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, "\n");
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i = 0; i < linesAndNewlines.length; i++) {
-    const line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
-    }
-  }
-  return retLines;
-}
-
-// src/lib/diff.ts
-function calculateDiffStats(oldContent, newContent) {
-  const changes = diffLines(oldContent, newContent);
-  let linesAdded = 0;
-  let linesRemoved = 0;
-  for (const change of changes) {
-    if (change.added) {
-      linesAdded += change.count || 0;
-    } else if (change.removed) {
-      linesRemoved += change.count || 0;
-    }
-  }
-  return { linesAdded, linesRemoved };
-}
-
-// src/tools/stringReplace.ts
-z.object({
-  file_path: z.string().describe("The path to the file you want to search and replace in. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is"),
-  new_string: z.string().describe("The edited text to replace the old_string (must be different from the old_string)"),
-  old_string: z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)"),
-  replaceAll: z.boolean().optional().describe("Replace all occurrences of old_string (default false)")
-});
-function levenshtein(a, b) {
-  if (a === "" || b === "") return Math.max(a.length, b.length);
-  const matrix = Array.from(
-    { length: a.length + 1 },
-    (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
-  );
-  for (let i = 1; i <= a.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
-    }
-  }
-  return matrix[a.length][b.length];
-}
-var SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0;
-var MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
-var SimpleReplacer = function* (_content, find) {
-  yield find;
-};
-var LineTrimmedReplacer = function* (content, find) {
-  const originalLines = content.split("\n");
-  const searchLines = find.split("\n");
-  if (searchLines[searchLines.length - 1] === "") searchLines.pop();
-  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
-    let matches = true;
-    for (let j = 0; j < searchLines.length; j++) {
-      if (originalLines[i + j].trim() !== searchLines[j].trim()) {
-        matches = false;
-        break;
-      }
-    }
-    if (matches) {
-      let matchStartIndex = 0;
-      for (let k = 0; k < i; k++) matchStartIndex += originalLines[k].length + 1;
-      let matchEndIndex = matchStartIndex;
-      for (let k = 0; k < searchLines.length; k++) {
-        matchEndIndex += originalLines[i + k].length;
-        if (k < searchLines.length - 1) matchEndIndex += 1;
-      }
-      yield content.substring(matchStartIndex, matchEndIndex);
-    }
-  }
-};
-var BlockAnchorReplacer = function* (content, find) {
-  const originalLines = content.split("\n");
-  const searchLines = find.split("\n");
-  if (searchLines.length < 3) return;
-  if (searchLines[searchLines.length - 1] === "") searchLines.pop();
-  const firstLineSearch = searchLines[0].trim();
-  const lastLineSearch = searchLines[searchLines.length - 1].trim();
-  const searchBlockSize = searchLines.length;
-  const candidates = [];
-  for (let i = 0; i < originalLines.length; i++) {
-    if (originalLines[i].trim() !== firstLineSearch) continue;
-    for (let j = i + 2; j < originalLines.length; j++) {
-      if (originalLines[j].trim() === lastLineSearch) {
-        candidates.push({ startLine: i, endLine: j });
-        break;
-      }
-    }
-  }
-  if (candidates.length === 0) return;
-  const computeSimilarity = (startLine, endLine) => {
-    const actualBlockSize = endLine - startLine + 1;
-    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
-    if (linesToCheck <= 0) return 1;
-    let similarity = 0;
-    for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
-      const originalLine = originalLines[startLine + j].trim();
-      const searchLine = searchLines[j].trim();
-      const maxLen = Math.max(originalLine.length, searchLine.length);
-      if (maxLen === 0) continue;
-      const distance = levenshtein(originalLine, searchLine);
-      similarity += (1 - distance / maxLen) / linesToCheck;
-    }
-    return similarity;
-  };
-  const extractBlock = (startLine, endLine) => {
-    let matchStartIndex = 0;
-    for (let k = 0; k < startLine; k++) matchStartIndex += originalLines[k].length + 1;
-    let matchEndIndex = matchStartIndex;
-    for (let k = startLine; k <= endLine; k++) {
-      matchEndIndex += originalLines[k].length;
-      if (k < endLine) matchEndIndex += 1;
-    }
-    return content.substring(matchStartIndex, matchEndIndex);
-  };
-  if (candidates.length === 1) {
-    const { startLine, endLine } = candidates[0];
-    if (computeSimilarity(startLine, endLine) >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
-      yield extractBlock(startLine, endLine);
-    }
-    return;
-  }
-  let bestMatch = null;
-  let maxSimilarity = -1;
-  for (const candidate of candidates) {
-    const similarity = computeSimilarity(candidate.startLine, candidate.endLine);
-    if (similarity > maxSimilarity) {
-      maxSimilarity = similarity;
-      bestMatch = candidate;
-    }
-  }
-  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
-    yield extractBlock(bestMatch.startLine, bestMatch.endLine);
-  }
-};
-var WhitespaceNormalizedReplacer = function* (content, find) {
-  const normalizeWhitespace = (text) => text.replace(/\s+/g, " ").trim();
-  const normalizedFind = normalizeWhitespace(find);
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (normalizeWhitespace(line) === normalizedFind) {
-      yield line;
-    } else {
-      const normalizedLine = normalizeWhitespace(line);
-      if (normalizedLine.includes(normalizedFind)) {
-        const words = find.trim().split(/\s+/);
-        if (words.length > 0) {
-          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
-          try {
-            const regex = new RegExp(pattern);
-            const match = line.match(regex);
-            if (match) yield match[0];
-          } catch {
-          }
-        }
-      }
-    }
-  }
-  const findLines = find.split("\n");
-  if (findLines.length > 1) {
-    for (let i = 0; i <= lines.length - findLines.length; i++) {
-      const block = lines.slice(i, i + findLines.length);
-      if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
-        yield block.join("\n");
-      }
-    }
-  }
-};
-var IndentationFlexibleReplacer = function* (content, find) {
-  const removeIndentation = (text) => {
-    const lines = text.split("\n");
-    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
-    if (nonEmptyLines.length === 0) return text;
-    const minIndent = Math.min(
-      ...nonEmptyLines.map((line) => {
-        const match = line.match(/^(\s*)/);
-        return match ? match[1].length : 0;
-      })
-    );
-    return lines.map((line) => line.trim().length === 0 ? line : line.slice(minIndent)).join("\n");
-  };
-  const normalizedFind = removeIndentation(find);
-  const contentLines = content.split("\n");
-  const findLines = find.split("\n");
-  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
-    const block = contentLines.slice(i, i + findLines.length).join("\n");
-    if (removeIndentation(block) === normalizedFind) {
-      yield block;
-    }
-  }
-};
-var EscapeNormalizedReplacer = function* (content, find) {
-  const unescapeString = (str) => {
-    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
-      switch (capturedChar) {
-        case "n":
-          return "\n";
-        case "t":
-          return "	";
-        case "r":
-          return "\r";
-        case "'":
-          return "'";
-        case '"':
-          return '"';
-        case "`":
-          return "`";
-        case "\\":
-          return "\\";
-        case "\n":
-          return "\n";
-        case "$":
-          return "$";
-        default:
-          return match;
-      }
-    });
-  };
-  const unescapedFind = unescapeString(find);
-  if (content.includes(unescapedFind)) {
-    yield unescapedFind;
-  }
-  const lines = content.split("\n");
-  const findLines = unescapedFind.split("\n");
-  for (let i = 0; i <= lines.length - findLines.length; i++) {
-    const block = lines.slice(i, i + findLines.length).join("\n");
-    if (unescapeString(block) === unescapedFind) {
-      yield block;
-    }
-  }
-};
-var TrimmedBoundaryReplacer = function* (content, find) {
-  const trimmedFind = find.trim();
-  if (trimmedFind === find) return;
-  if (content.includes(trimmedFind)) {
-    yield trimmedFind;
-  }
-  const lines = content.split("\n");
-  const findLines = find.split("\n");
-  for (let i = 0; i <= lines.length - findLines.length; i++) {
-    const block = lines.slice(i, i + findLines.length).join("\n");
-    if (block.trim() === trimmedFind) {
-      yield block;
-    }
-  }
-};
-var ContextAwareReplacer = function* (content, find) {
-  const findLines = find.split("\n");
-  if (findLines.length < 3) return;
-  if (findLines[findLines.length - 1] === "") findLines.pop();
-  const contentLines = content.split("\n");
-  const firstLine = findLines[0].trim();
-  const lastLine = findLines[findLines.length - 1].trim();
-  for (let i = 0; i < contentLines.length; i++) {
-    if (contentLines[i].trim() !== firstLine) continue;
-    for (let j = i + 2; j < contentLines.length; j++) {
-      if (contentLines[j].trim() === lastLine) {
-        const blockLines = contentLines.slice(i, j + 1);
-        if (blockLines.length === findLines.length) {
-          let matchingLines = 0;
-          let totalNonEmptyLines = 0;
-          for (let k = 1; k < blockLines.length - 1; k++) {
-            const blockLine = blockLines[k].trim();
-            const findLine = findLines[k].trim();
-            if (blockLine.length > 0 || findLine.length > 0) {
-              totalNonEmptyLines++;
-              if (blockLine === findLine) matchingLines++;
-            }
-          }
-          if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
-            yield blockLines.join("\n");
-            break;
-          }
-        }
-        break;
-      }
-    }
-  }
-};
-var MultiOccurrenceReplacer = function* (content, find) {
-  let startIndex = 0;
-  while (true) {
-    const index = content.indexOf(find, startIndex);
-    if (index === -1) break;
-    yield find;
-    startIndex = index + find.length;
-  }
-};
-var REPLACERS = [
-  SimpleReplacer,
-  LineTrimmedReplacer,
-  BlockAnchorReplacer,
-  WhitespaceNormalizedReplacer,
-  IndentationFlexibleReplacer,
-  EscapeNormalizedReplacer,
-  TrimmedBoundaryReplacer,
-  ContextAwareReplacer,
-  MultiOccurrenceReplacer
-];
-function smartReplace(content, oldString, newString, replaceAll = false) {
-  if (oldString === newString) {
-    throw new Error("No changes to apply: oldString and newString are identical.");
-  }
-  let notFound = true;
-  for (const replacer of REPLACERS) {
-    for (const search of replacer(content, oldString)) {
-      const index = content.indexOf(search);
-      if (index === -1) continue;
-      notFound = false;
-      if (replaceAll) {
-        return content.replaceAll(search, newString);
-      }
-      const lastIndex = content.lastIndexOf(search);
-      if (index !== lastIndex) continue;
-      return content.substring(0, index) + newString + content.substring(index + search.length);
-    }
-  }
-  if (notFound) {
-    throw new Error(
-      "oldString not found in content. It must match the file contents exactly, including whitespace, indentation, and line endings."
-    );
-  }
-  throw new Error(
-    "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match."
-  );
-}
-var apply_patch = async function(input, projectCwd) {
-  const { file_path, new_string, old_string, replaceAll: shouldReplaceAll = false } = input;
-  try {
-    if (!file_path) {
-      return {
-        success: false,
-        message: "Missing required parameter: file_path",
-        error: "MISSING_FILE_PATH"
-      };
-    }
-    if (old_string === void 0 || old_string === null) {
-      return {
-        success: false,
-        message: "Missing required parameter: old_string",
-        error: "MISSING_OLD_STRING"
-      };
-    }
-    if (new_string === void 0 || new_string === null) {
-      return {
-        success: false,
-        message: "Missing required parameter: new_string",
-        error: "MISSING_NEW_STRING"
-      };
-    }
-    if (old_string === new_string) {
-      return {
-        success: false,
-        message: "old_string and new_string must be different",
-        error: "STRINGS_IDENTICAL"
-      };
-    }
-    if (projectCwd) {
-      const validation = validatePath(file_path, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
-      }
-    }
-    const basePath = projectCwd || process.cwd();
-    const absolute_file_path = resolveProjectPath(file_path, basePath);
-    const file = Bun.file(absolute_file_path);
-    const exists = await file.exists();
-    if (!exists) {
-      if (old_string === "") {
-        const { mkdir: mkdir2 } = await import('fs/promises');
-        const path14 = await import('path');
-        await mkdir2(path14.dirname(absolute_file_path), { recursive: true });
-        await Bun.write(absolute_file_path, new_string);
-        const diffStats = calculateDiffStats("", new_string);
-        return {
-          success: true,
-          isNewFile: true,
-          old_string: "",
-          new_string,
-          linesAdded: diffStats.linesAdded,
-          linesRemoved: diffStats.linesRemoved,
-          message: `Created new file: ${file_path}`
-        };
-      }
-      return {
-        success: false,
-        message: `File not found: ${file_path}`,
-        error: "FILE_NOT_FOUND"
-      };
-    }
-    let fileContent;
-    try {
-      fileContent = await file.text();
-    } catch (error) {
-      return {
-        success: false,
-        message: `Failed to read file: ${file_path}`,
-        error: "READ_ERROR"
-      };
-    }
-    let newContent;
-    try {
-      newContent = smartReplace(fileContent, old_string, new_string, shouldReplaceAll);
-    } catch (err) {
-      if (err.message.includes("not found")) {
-        return {
-          success: false,
-          message: `old_string not found in file: ${file_path}. Ensure it matches the file contents exactly, including whitespace and indentation.`,
-          error: "STRING_NOT_FOUND"
-        };
-      }
-      if (err.message.includes("multiple matches")) {
-        const occurrences = fileContent.split(old_string).length - 1;
-        return {
-          success: false,
-          message: `old_string appears ${occurrences > 1 ? occurrences + " times" : "multiple times (via fuzzy match)"} in the file. Provide more surrounding context to make it unique, or set replaceAll to true.`,
-          error: "STRING_NOT_UNIQUE"
-        };
-      }
-      return {
-        success: false,
-        message: err.message,
-        error: "REPLACE_ERROR"
-      };
-    }
-    try {
-      await Bun.write(absolute_file_path, newContent);
-      const diffStats = calculateDiffStats(fileContent, newContent);
-      return {
-        success: true,
-        old_string,
-        new_string,
-        linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved,
-        message: `Successfully replaced string in file: ${file_path}`
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: `Failed to write to file: ${file_path}`,
-        error: "WRITE_ERROR"
-      };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      message: `Unexpected error: ${error.message}`,
-      error: "UNEXPECTED_ERROR"
-    };
-  }
-};
-var DEFAULT_SERVER_URL = "wss://bridge.ama.shujan.xyz";
-var AMA_DIR = path10.join(os3.homedir(), ".amai");
-path10.join(AMA_DIR, "code");
-path10.join(AMA_DIR, "storage");
-z.object({
-  target_file: z.string().describe("The relative path to the file to modify. The tool will create any directories in the path that don't exist"),
-  content: z.string().describe("The full content to write to the file"),
-  providedNewFile: z.boolean().describe("Whether this is a new file (true) or an edit to an existing file (false). Auto-detected if omitted.").optional()
-});
-var editFiles = async function(input, projectCwd) {
-  const { target_file, content, providedNewFile } = input;
-  if (!target_file) {
-    return {
-      success: false,
-      error: "Missing required parameter: target_file",
-      message: "target_file is required"
-    };
-  }
-  try {
-    if (projectCwd) {
-      const validation = validatePath(target_file, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          error: validation.error || "Path validation failed",
-          message: `Failed to edit file: ${target_file}`
-        };
-      }
-    }
-    const basePath = projectCwd || process.cwd();
-    const filePath = resolveProjectPath(target_file, basePath);
-    const dirPath = path10.dirname(filePath);
-    await mkdir(dirPath, { recursive: true });
-    let isNewFile = providedNewFile;
-    let existingContent = "";
-    const file = Bun.file(filePath);
-    if (isNewFile === void 0) {
-      const exists = await file.exists();
-      if (exists) {
-        existingContent = await file.text();
-        isNewFile = false;
-      } else {
-        isNewFile = true;
-      }
-    } else if (!isNewFile) {
-      const exists = await file.exists();
-      if (exists) {
-        existingContent = await file.text();
-      } else {
-        isNewFile = true;
-      }
-    }
-    if (!isNewFile && existingContent === content) {
-      return {
-        success: true,
-        isNewFile: false,
-        message: `No changes needed: ${target_file} (content identical)`,
-        linesAdded: 0,
-        linesRemoved: 0
-      };
-    }
-    await Bun.write(filePath, content);
-    const diffStats = calculateDiffStats(existingContent, content);
-    if (isNewFile) {
-      return {
-        success: true,
-        isNewFile: true,
-        old_string: "",
-        new_string: content,
-        message: `Created new file: ${target_file} (+${diffStats.linesAdded} lines)`,
-        linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
-      };
-    } else {
-      return {
-        success: true,
-        isNewFile: false,
-        old_string: existingContent,
-        new_string: content,
-        message: `Modified file: ${target_file} (+${diffStats.linesAdded} -${diffStats.linesRemoved} lines)`,
-        linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
-      };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-      message: `Failed to edit file: ${target_file}`
-    };
-  }
-};
-z.object({
-  path: z.string().describe("Relative file path to delete")
-});
-var deleteFile = async function(input, projectCwd) {
-  const { path: realPath } = input;
-  if (!realPath) {
-    return {
-      success: false,
-      message: "Missing required parameter: path",
-      error: "MISSING_PATH"
-    };
-  }
-  if (projectCwd) {
-    const validation = validatePath(realPath, projectCwd);
-    if (!validation.valid) {
-      return {
-        success: false,
-        message: validation.error || "Path validation failed",
-        error: "ACCESS_DENIED"
-      };
-    }
-  }
-  try {
-    const basePath = projectCwd || process.cwd();
-    const absolute_file_path = resolveProjectPath(realPath, basePath);
-    if (!absolute_file_path) {
-      return {
-        success: false,
-        message: "Invalid file path",
-        error: "INVALID_FILE_PATH"
-      };
-    }
-    const file = Bun.file(absolute_file_path);
-    const exists = await file.exists();
-    if (!exists) {
-      return {
-        success: false,
-        message: `File not found: ${realPath}`,
-        error: "FILE_NOT_FOUND"
-      };
-    }
-    let originalContent;
-    try {
-      originalContent = await file.text();
-    } catch {
-      return {
-        success: false,
-        message: `Failed to read file before deletion: ${realPath}`,
-        error: "READ_ERROR"
-      };
-    }
-    try {
-      await unlink(absolute_file_path);
-    } catch {
-      return {
-        success: false,
-        message: `Failed to delete file: ${realPath}`,
-        error: "DELETE_ERROR"
-      };
-    }
-    return {
-      success: true,
-      message: `Successfully deleted file: ${realPath}`,
-      content: originalContent
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to delete file: ${realPath}`,
-      error: "DELETE_ERROR"
-    };
-  }
-};
-var GREP_LIMITS = {
-  DEFAULT_MAX_MATCHES: 200,
-  MAX_LINE_LENGTH: 2e3,
-  // aligned with OpenCode's 2000-char truncation
-  MAX_TOTAL_OUTPUT_SIZE: 1 * 1024 * 1024,
-  EXECUTION_TIMEOUT_MS: 15e3,
-  TRUNCATION_MESSAGE: "\n[Results truncated due to size limits. Use more specific patterns or file filters to narrow your search.]"
-};
-z.object({
-  query: z.string().describe("The regex pattern to search for"),
-  options: z.object({
-    includePattern: z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts", "*.{ts,tsx}")'),
-    excludePattern: z.string().optional().describe("Glob pattern for files to exclude"),
-    caseSensitive: z.boolean().optional().describe("Whether the search should be case sensitive"),
-    path: z.string().optional().describe("Subdirectory to search in"),
-    sortByMtime: z.boolean().optional().describe("Sort results by file modification time (default: true)")
-  }).optional()
-});
-var _cachedRgPath = null;
-async function getRipgrepPath() {
-  if (_cachedRgPath) return _cachedRgPath;
-  const paths = [
-    "/opt/homebrew/bin/rg",
-    "/usr/local/bin/rg",
-    "/usr/bin/rg"
-  ];
-  for (const rgPath of paths) {
-    if (fs8.existsSync(rgPath)) {
-      _cachedRgPath = rgPath;
-      return rgPath;
-    }
-  }
-  _cachedRgPath = "rg";
-  return "rg";
-}
-getRipgrepPath();
-async function getMtimesBatched(files) {
-  const mtimeMap = /* @__PURE__ */ new Map();
-  const BATCH_SIZE = 50;
-  for (let i = 0; i < files.length; i += BATCH_SIZE) {
-    const batch = files.slice(i, i + BATCH_SIZE);
-    const results = await Promise.all(
-      batch.map(async (filePath) => {
-        const mtime = await Bun.file(filePath).stat().then((stats) => stats.mtime.getTime()).catch(() => 0);
-        return { path: filePath, mtime };
-      })
-    );
-    results.forEach(({ path: path14, mtime }) => mtimeMap.set(path14, mtime));
-  }
-  return mtimeMap;
-}
-var grepTool = async function(input, projectCwd) {
-  const { query, options } = input;
-  if (!query || query.trim() === "") {
-    return {
-      success: false,
-      message: "Missing required parameter: query",
-      error: "MISSING_QUERY"
-    };
-  }
-  try {
-    const { includePattern, excludePattern, caseSensitive, path: subPath, sortByMtime = true } = options || {};
-    let searchDir = projectCwd || process.cwd();
-    if (subPath) {
-      searchDir = path10.isAbsolute(subPath) ? subPath : path10.resolve(searchDir, subPath);
-      if (projectCwd) {
-        const validation = validatePath(subPath, projectCwd);
-        if (!validation.valid) {
-          return {
-            success: false,
-            message: validation.error || "Path validation failed",
-            error: "ACCESS_DENIED"
-          };
-        }
-      }
-    }
-    if (!fs8.existsSync(searchDir)) {
-      return {
-        success: false,
-        message: `Directory not found: ${searchDir}`,
-        error: "DIR_NOT_FOUND"
-      };
-    }
-    const rgPath = await getRipgrepPath();
-    const args = [
-      "-nH",
-      // line numbers + filename (compact form, matching OpenCode)
-      "--hidden",
-      // search hidden files (aligned with OpenCode)
-      "--no-messages",
-      // suppress error messages for unreadable files
-      "--color=never",
-      "--max-count=100",
-      "--max-columns=2000"
-    ];
-    if (!caseSensitive) {
-      args.push("-i");
-    }
-    if (includePattern) {
-      args.push("--glob", includePattern);
-    }
-    if (excludePattern) {
-      args.push("--glob", `!${excludePattern}`);
-    }
-    args.push("--glob", "!node_modules/**");
-    args.push("--glob", "!.git/**");
-    args.push("--glob", "!dist/**");
-    args.push("--glob", "!build/**");
-    args.push("--glob", "!*.min.js");
-    args.push("--glob", "!*.min.css");
-    args.push("--glob", "!package-lock.json");
-    args.push("--glob", "!yarn.lock");
-    args.push("--glob", "!bun.lockb");
-    args.push("--glob", "!pnpm-lock.yaml");
-    args.push("--regexp", query);
-    args.push(searchDir);
-    const proc = Bun.spawn([rgPath, ...args], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    let timedOut = false;
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      proc.kill();
-    }, GREP_LIMITS.EXECUTION_TIMEOUT_MS);
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-    clearTimeout(timeoutId);
-    if (timedOut) {
-      return {
-        success: false,
-        message: `Search timed out after ${GREP_LIMITS.EXECUTION_TIMEOUT_MS}ms. Use more specific patterns.`,
-        error: "GREP_TIMEOUT"
-      };
-    }
-    if (exitCode === 1) {
-      return {
-        success: true,
-        matches: [],
-        detailedMatches: [],
-        query,
-        matchCount: 0,
-        message: `No matches found for pattern: ${query}`
-      };
-    }
-    if (exitCode !== 0 && exitCode !== 2) {
-      return {
-        success: false,
-        message: `Ripgrep error: ${stderr || "Unknown error"}`,
-        error: "GREP_EXEC_ERROR"
-      };
-    }
-    const lines = stdout.trim().split("\n").filter((line) => line.length > 0);
-    const rawMatches = [];
-    const uniqueFiles = /* @__PURE__ */ new Set();
-    for (const line of lines) {
-      const firstColon = line.indexOf(":");
-      const secondColon = line.indexOf(":", firstColon + 1);
-      if (firstColon > 0 && secondColon > firstColon) {
-        const file = line.substring(0, firstColon);
-        const lineNumber = parseInt(line.substring(firstColon + 1, secondColon), 10);
-        let content = line.substring(secondColon + 1);
-        if (content.length > GREP_LIMITS.MAX_LINE_LENGTH) {
-          content = content.substring(0, GREP_LIMITS.MAX_LINE_LENGTH) + "...";
-        }
-        rawMatches.push({
-          file,
-          lineNumber,
-          content: content.trim(),
-          mtime: 0
-        });
-        uniqueFiles.add(file);
-      }
-    }
-    if (sortByMtime && uniqueFiles.size > 0) {
-      const mtimeMap = await getMtimesBatched(Array.from(uniqueFiles));
-      for (const match of rawMatches) {
-        match.mtime = mtimeMap.get(match.file) || 0;
-      }
-      rawMatches.sort((a, b) => {
-        if (b.mtime !== a.mtime) return b.mtime - a.mtime;
-        return a.file.localeCompare(b.file);
-      });
-    }
-    const truncated = rawMatches.length > GREP_LIMITS.DEFAULT_MAX_MATCHES;
-    const finalMatches = truncated ? rawMatches.slice(0, GREP_LIMITS.DEFAULT_MAX_MATCHES) : rawMatches;
-    const detailedMatches = finalMatches.map((m) => ({
-      file: m.file,
-      lineNumber: m.lineNumber,
-      content: m.content
-    }));
-    const matches = finalMatches.map(
-      (m) => `${m.file}:${m.lineNumber}:${m.content}`
-    );
-    const groupedOutput = [`Found ${finalMatches.length} matches`];
-    let currentFile = "";
-    for (const match of finalMatches) {
-      if (currentFile !== match.file) {
-        if (currentFile !== "") {
-          groupedOutput.push("");
-        }
-        currentFile = match.file;
-        groupedOutput.push(`${match.file}:`);
-      }
-      groupedOutput.push(`  Line ${match.lineNumber}: ${match.content}`);
-    }
-    if (truncated) {
-      groupedOutput.push("");
-      groupedOutput.push(GREP_LIMITS.TRUNCATION_MESSAGE);
-    }
-    return {
-      success: true,
-      matches,
-      detailedMatches,
-      query,
-      matchCount: finalMatches.length,
-      truncated,
-      message: `Found ${finalMatches.length} matches for pattern: ${query}`,
-      content: groupedOutput.join("\n")
-    };
-  } catch (error) {
-    console.error("[grep] error:", error);
-    return {
-      success: false,
-      message: error?.message || String(error),
-      error: "GREP_EXEC_ERROR"
-    };
-  }
-};
-z.object({
-  pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.js", "src/**/*.ts", "*.json"). Supports standard glob syntax with *, **, and ? wildcards'),
-  path: z.string().optional().describe("Optional directory path to limit the search scope. If not provided, searches from the project root")
-});
-var RESULT_LIMIT = 100;
-var MTIME_BATCH_SIZE = 50;
-async function getMtimesBatched2(files) {
-  const results = [];
-  for (let i = 0; i < files.length; i += MTIME_BATCH_SIZE) {
-    const batch = files.slice(i, i + MTIME_BATCH_SIZE);
-    const batchResults = await Promise.all(
-      batch.map(async (filePath) => {
-        const mtime = await Bun.file(filePath).stat().then((stats) => stats.mtime.getTime()).catch(() => 0);
-        return { path: filePath, mtime };
-      })
-    );
-    results.push(...batchResults);
-  }
-  return results;
-}
-var globTool = async function(input, projectCwd) {
-  const { pattern, path: inputPath } = input;
-  if (!pattern) {
-    return {
-      success: false,
-      message: "Missing required parameter: pattern",
-      error: "MISSING_PATTERN"
-    };
-  }
-  try {
-    const basePath = projectCwd || process.cwd();
-    const searchPath = inputPath ? resolveProjectPath(inputPath, basePath) : basePath;
-    if (!fs8.existsSync(searchPath)) {
-      return {
-        success: false,
-        message: `Directory not found: ${searchPath}`,
-        error: "DIR_NOT_FOUND"
-      };
-    }
-    if (projectCwd && inputPath) {
-      const validation = validatePath(inputPath, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
-      }
-    }
-    const glob = new Bun.Glob(pattern);
-    const files = [];
-    let truncated = false;
-    for await (const match of glob.scan({
-      cwd: searchPath,
-      absolute: true,
-      onlyFiles: true,
-      followSymlinks: false
-    })) {
-      if (match.includes("/node_modules/") || match.includes("/.git/")) {
-        continue;
-      }
-      if (files.length >= RESULT_LIMIT) {
-        truncated = true;
-        break;
-      }
-      files.push(match);
-    }
-    let sortedFiles;
-    if (files.length > 0) {
-      const filesWithMtime = await getMtimesBatched2(files);
-      filesWithMtime.sort((a, b) => b.mtime - a.mtime);
-      sortedFiles = filesWithMtime.map((f) => f.path);
-    } else {
-      sortedFiles = files;
-    }
-    const output = [];
-    if (sortedFiles.length === 0) {
-      output.push("No files found");
-    } else {
-      output.push(...sortedFiles);
-      if (truncated) {
-        output.push("");
-        output.push("(Results are truncated. Consider using a more specific path or pattern.)");
-      }
-    }
-    const searchLocation = inputPath ? ` in "${inputPath}"` : " in current directory";
-    const message = `Found ${sortedFiles.length} matches for pattern "${pattern}"${searchLocation}`;
-    return {
-      success: true,
-      message,
-      metadata: {
-        count: sortedFiles.length,
-        truncated
-      },
-      content: output.join("\n")
-    };
-  } catch (error) {
-    console.error("[glob] error:", error);
-    return {
-      success: false,
-      message: `Failed to find files matching pattern: ${pattern}`,
-      error: "GLOB_ERROR"
-    };
-  }
-};
-var DEFAULT_IGNORE_PATTERNS = [
-  "node_modules",
-  "__pycache__",
-  ".git",
-  "dist",
-  "build",
-  "target",
-  "vendor",
-  "bin",
-  "obj",
-  ".idea",
-  ".vscode",
-  ".zig-cache",
-  "zig-out",
-  ".coverage",
-  "coverage",
-  "tmp",
-  "temp",
-  ".cache",
-  "cache",
-  "logs",
-  ".venv",
-  "venv",
-  "env",
-  ".next",
-  ".turbo",
-  ".vercel",
-  ".output"
-];
-var RESULT_LIMIT2 = 500;
-var MTIME_BATCH_SIZE2 = 50;
-z.object({
-  path: z.string().optional().describe("Path to the directory to list"),
-  recursive: z.boolean().optional().describe("Whether to list files recursively (default: true)"),
-  maxDepth: z.number().optional().describe("Maximum recursion depth (default: 3)"),
-  pattern: z.string().optional().describe("File extension (e.g., '.ts') or glob-like pattern"),
-  showHidden: z.boolean().optional().describe("Whether to show hidden files (default: false)"),
-  includeMetadata: z.boolean().optional().describe("Whether to fetch file metadata like mtime (default: false -- faster without I/O)"),
-  ignore: z.array(z.string()).optional().describe("Additional glob patterns to ignore (added to default ignore list)")
-});
-function shouldIgnore(name, showHidden, ignoreSet) {
-  if (!showHidden && name.startsWith(".") && name !== ".") {
-    return true;
-  }
-  return ignoreSet.has(name);
-}
-function matchPattern(name, pattern) {
-  if (!pattern) return true;
-  if (pattern.startsWith(".") && !pattern.includes("*")) {
-    return name.endsWith(pattern);
-  }
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  const regex = new RegExp(`^${escaped}$`, "i");
-  return regex.test(name);
-}
-async function getMtimesBatched3(entries) {
-  for (let i = 0; i < entries.length; i += MTIME_BATCH_SIZE2) {
-    const batch = entries.slice(i, i + MTIME_BATCH_SIZE2);
-    await Promise.all(
-      batch.map(async (entry) => {
-        entry.mtime = await Bun.file(entry.absolutePath).stat().then((stats) => stats.mtime.getTime()).catch(() => 0);
-      })
-    );
-  }
-}
-function buildTreeOutput(entries, basePath) {
-  const tree = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const dir = path10.dirname(entry.relativePath);
-    const dirKey = dir === "." ? "" : dir;
-    if (!tree.has(dirKey)) {
-      tree.set(dirKey, []);
-    }
-    tree.get(dirKey).push(entry);
-  }
-  for (const [, items] of tree) {
-    items.sort((a, b) => {
-      if (a.type !== b.type) {
-        return a.type === "directory" ? -1 : 1;
-      }
-      return a.name.localeCompare(b.name);
-    });
-  }
-  const lines = [`${basePath}/`];
-  function renderLevel(dirPath, indent) {
-    const items = tree.get(dirPath) || [];
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i];
-      const isLast = i === items.length - 1;
-      const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      const childIndent = indent + (isLast ? "    " : "\u2502   ");
-      if (item.type === "directory") {
-        lines.push(`${indent}${prefix}${item.name}/`);
-        const childPath = dirPath ? `${dirPath}/${item.name}` : item.name;
-        renderLevel(childPath, childIndent);
-      } else {
-        lines.push(`${indent}${prefix}${item.name}`);
-      }
-    }
-  }
-  renderLevel("", "");
-  return lines.join("\n");
-}
-var list = async function(input, projectCwd) {
-  const {
-    path: relativePath,
-    recursive = true,
-    maxDepth = 3,
-    pattern,
-    showHidden = false,
-    includeMetadata = false,
-    ignore: extraIgnore
-  } = input;
-  if (maxDepth !== void 0 && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
-    return {
-      success: false,
-      message: "maxDepth must be a non-negative integer",
-      error: "INVALID_MAX_DEPTH"
-    };
-  }
-  try {
-    const basePath = projectCwd || process.cwd();
-    const absolutePath = relativePath ? resolveProjectPath(relativePath, basePath) : basePath;
-    if (projectCwd && relativePath) {
-      const validation = validatePath(relativePath, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
-      }
-    }
-    if (!fs8.existsSync(absolutePath)) {
-      return {
-        success: false,
-        message: `Directory not found: ${absolutePath}`,
-        error: "DIR_NOT_FOUND"
-      };
-    }
-    const stats = fs8.statSync(absolutePath);
-    if (!stats.isDirectory()) {
-      return {
-        success: false,
-        message: `Path is not a directory: ${absolutePath}`,
-        error: "NOT_A_DIRECTORY"
-      };
-    }
-    const ignoreSet = new Set(DEFAULT_IGNORE_PATTERNS);
-    if (extraIgnore && extraIgnore.length > 0) {
-      for (const pat of extraIgnore) {
-        ignoreSet.add(pat);
-      }
-    }
-    const collected = [];
-    let truncated = false;
-    const walk = async (currentDir, depth) => {
-      if (collected.length >= RESULT_LIMIT2) {
-        truncated = true;
-        return;
-      }
-      let entries;
-      try {
-        entries = fs8.readdirSync(currentDir, { withFileTypes: true });
-      } catch {
-        return;
-      }
-      entries.sort((a, b) => {
-        if (a.isDirectory() !== b.isDirectory()) {
-          return a.isDirectory() ? -1 : 1;
-        }
-        return a.name.localeCompare(b.name);
-      });
-      for (const entry of entries) {
-        if (collected.length >= RESULT_LIMIT2) {
-          truncated = true;
-          break;
-        }
-        if (shouldIgnore(entry.name, showHidden, ignoreSet)) {
-          continue;
-        }
-        const entryAbsolutePath = path10.join(currentDir, entry.name);
-        const entryRelativePath = path10.relative(absolutePath, entryAbsolutePath);
-        if (entry.isDirectory()) {
-          collected.push({
-            name: entry.name,
-            absolutePath: entryAbsolutePath,
-            relativePath: entryRelativePath,
-            type: "directory",
-            mtime: 0,
-            depth
-          });
-          if (recursive && depth < maxDepth) {
-            await walk(entryAbsolutePath, depth + 1);
-          }
-        } else if (entry.isFile()) {
-          if (matchPattern(entry.name, pattern)) {
-            collected.push({
-              name: entry.name,
-              absolutePath: entryAbsolutePath,
-              relativePath: entryRelativePath,
-              type: "file",
-              mtime: 0,
-              depth
-            });
-          }
-        }
-      }
-    };
-    await walk(absolutePath, 0);
-    if (includeMetadata) {
-      await getMtimesBatched3(collected);
-    }
-    const totalFiles = collected.filter((item) => item.type === "file").length;
-    const totalDirectories = collected.filter((item) => item.type === "directory").length;
-    const treeOutput = buildTreeOutput(collected, relativePath || path10.basename(absolutePath));
-    let message = `Listed ${collected.length} items`;
-    if (relativePath) {
-      message += ` in "${relativePath}"`;
-    }
-    message += ` (${totalFiles} files, ${totalDirectories} directories)`;
-    if (recursive) {
-      message += ` [depth: ${maxDepth}]`;
-    }
-    if (pattern) {
-      message += ` [filter: ${pattern}]`;
-    }
-    if (truncated) {
-      message += ` [TRUNCATED at ${RESULT_LIMIT2} items]`;
-    }
-    const files = collected.map((item) => ({
-      name: item.name,
-      path: item.relativePath,
-      type: item.type
-    }));
-    return {
-      success: true,
-      message,
-      metadata: {
-        totalFiles,
-        totalDirectories,
-        totalItems: collected.length,
-        truncated,
-        maxDepth,
-        recursive
-      },
-      files,
-      content: treeOutput
-    };
-  } catch (error) {
-    console.error("[list] error:", error);
-    return {
-      success: false,
-      message: `Failed to list directory: ${error}`,
-      error: "LIST_ERROR"
-    };
-  }
-};
+import path6 from 'path';
+import os3 from 'os';
+import pc3 from 'picocolors';
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { cors } from 'hono/cors';
+import fs4, { readdirSync } from 'fs';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import fs5 from 'fs/promises';
+import { z } from 'zod';
+import { createServer } from 'http';
+import { batchTool, bashTool, apply_patch, read_file, list, globTool, grepTool, deleteFile, editFiles } from '@ama/agent';
+
+var DEFAULT_SERVER_URL = "wss://bridge.ama.shujan.xyz";
+var AMA_DIR = path6.join(os3.homedir(), ".amai");
+path6.join(AMA_DIR, "code");
+path6.join(AMA_DIR, "storage");
 var startHttpServer = () => {
   const app = new Hono();
   app.use(cors());
@@ -1866,22 +33,22 @@ var startHttpServer = () => {
     }
   });
 };
-var CREDENTIALS_DIR = path10.join(os3.homedir(), ".amai");
-var CREDENTIALS_PATH = path10.join(CREDENTIALS_DIR, "credentials.json");
+var CREDENTIALS_DIR = path6.join(os3.homedir(), ".amai");
+var CREDENTIALS_PATH = path6.join(CREDENTIALS_DIR, "credentials.json");
 function getTokens() {
-  if (!fs8.existsSync(CREDENTIALS_PATH)) {
+  if (!fs4.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs8.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs4.readFileSync(CREDENTIALS_PATH, "utf8");
   const data = JSON.parse(raw);
   return data;
 }
 var getUserId = () => {
   try {
-    if (!fs8.existsSync(CREDENTIALS_PATH)) {
+    if (!fs4.existsSync(CREDENTIALS_PATH)) {
       return;
     }
-    const raw = fs8.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs4.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     const fromUserObject = data.user?.id;
     const fromTopLevel = data.sub ?? data.user_id;
@@ -1906,168 +73,54 @@ var getUserId = () => {
     throw new Error("Error while getting userId");
   }
 };
-var ExplanationSchema = z.object({
-  description: z.string().describe(
-    "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'"
-  )
-});
-var BLOCKED_PATTERNS = [
-  /\brm\s+(-\w+\s+)*(\/ |\/\s*$|~|\/\*|\*)/,
-  /\bdd\s+.*of=\/dev\//,
-  /\bmkfs\b/,
-  /:\(\)\{.*\|.*&\}\s*;?\s*:/,
-  /\bchmod\s+.*-R.*\s+\/\s*$/,
-  /\bchown\s+.*-R.*\s+\/\s*$/,
-  /\b(curl|wget)\s+.*\|\s*(ba)?sh/,
-  /\bmv\s+(\/|\*)\s/,
-  /\bcat\s+\/dev\/(u?random|zero)\s*>\s*\/dev\//,
-  /\bformat\s+[A-Z]:/i,
-  /\bdiskpart\b/i,
-  /\bcipher\s+\/w:/i
-];
-var DANGEROUS_FLAGS = [
-  /--no-preserve-root/,
-  /\bgit\s+push\s+.*--force\b/,
-  /\bgit\s+push\s+-f\b/
-];
-var MAX_OUTPUT_SIZE = 1 * 1024 * 1024;
-var DEFAULT_TIMEOUT = 12e4;
-function evaluateCommandSafety(command) {
-  const trimmed = command.trim();
-  for (const pattern of BLOCKED_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return { safe: false, reason: `Blocked by safety policy: matches destructive pattern` };
-    }
-  }
-  for (const flag of DANGEROUS_FLAGS) {
-    if (flag.test(trimmed)) {
-      return { safe: false, reason: `Blocked by safety policy: dangerous flag detected` };
-    }
-  }
-  return { safe: true };
+var MUTATING_TOOLS = /* @__PURE__ */ new Set([
+  "editFile",
+  "deleteFile",
+  "stringReplace",
+  "bash"
+]);
+function isMutatingTool(toolName) {
+  return MUTATING_TOOLS.has(toolName);
 }
-z.object({
-  command: z.string().describe("The terminal command to execute"),
-  is_background: z.boolean().optional().default(false).describe("Whether the command should be run in the background"),
-  timeout: z.number().optional().describe("Optional timeout in milliseconds. If not specified, commands will time out after 120000ms (2 minutes)."),
-  workdir: z.string().optional().describe("The working directory to run the command in. Defaults to the project directory. Use this instead of 'cd' commands.")
-}).merge(ExplanationSchema);
-var runSecureTerminalCommand = async (command, timeout, cwd) => {
+function isPathWithinProject(filePath, projectCwd) {
   try {
-    const safety = evaluateCommandSafety(command);
-    if (!safety.safe) {
-      console.log(`[CLI] Blocked command: ${command} \u2014 ${safety.reason}`);
-      return {
-        success: false,
-        message: safety.reason,
-        error: "BLOCKED_COMMAND"
-      };
-    }
-    const proc = Bun.spawn(["sh", "-c", command], {
-      cwd: cwd || process.cwd(),
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    let timedOut = false;
-    let timeoutId = null;
-    if (timeout > 0) {
-      timeoutId = setTimeout(() => {
-        timedOut = true;
-        proc.kill();
-      }, timeout);
-    }
-    const [stdout, stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited
-    ]);
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    if (timedOut) {
-      return {
-        success: false,
-        message: `Command timed out after ${timeout}ms`,
-        error: "TIMEOUT",
-        stdout: stdout.slice(0, MAX_OUTPUT_SIZE),
-        stderr: stderr.slice(0, MAX_OUTPUT_SIZE)
-      };
+    const resolvedCwd = safeRealpath(projectCwd);
+    const resolved = path6.resolve(resolvedCwd, filePath);
+    const resolvedTarget = safeRealpath(resolved);
+    const rel = path6.relative(resolvedCwd, resolvedTarget);
+    if (rel.startsWith("..") || path6.isAbsolute(rel)) {
+      return false;
     }
-    return {
-      stdout: stdout.slice(0, MAX_OUTPUT_SIZE),
-      stderr: stderr.slice(0, MAX_OUTPUT_SIZE),
-      exitCode
-    };
-  } catch (error) {
-    console.error("Error while executing the securedShell command", error);
-    return {
-      success: false,
-      message: "Error while executing the securedShell command",
-      error: error.message
-    };
+    return true;
+  } catch {
+    return false;
   }
-};
-var bashTool = async (input, projectCwd) => {
+}
+function safeRealpath(p) {
   try {
-    const safety = evaluateCommandSafety(input.command);
-    if (!safety.safe) {
-      console.log(`[CLI] Blocked command: ${input.command} \u2014 ${safety.reason}`);
-      return {
-        success: false,
-        message: safety.reason,
-        error: "BLOCKED_COMMAND"
-      };
-    }
-    if (input.timeout !== void 0 && input.timeout < 0) {
-      return {
-        success: false,
-        message: `Invalid timeout value: ${input.timeout}. Timeout must be a positive number.`,
-        error: "INVALID_TIMEOUT"
-      };
-    }
-    const cwd = input.workdir || projectCwd || process.cwd();
-    const timeout = input.timeout ?? DEFAULT_TIMEOUT;
-    if (input?.is_background) {
-      const proc = Bun.spawn(["sh", "-c", input.command], {
-        cwd,
-        stdout: "ignore",
-        stderr: "ignore"
-      });
-      proc.unref();
-      console.log(`[LOCAL] Background command started: ${input.command}`);
-      return {
-        success: true,
-        message: `Background command started: ${input.command}`,
-        isBackground: true
-      };
-    } else {
-      const result = await runSecureTerminalCommand(
-        input.command,
-        timeout,
-        cwd
-      );
-      if (result?.error && !result?.exitCode) {
-        return result;
-      }
-      const success = result?.exitCode === 0;
-      return {
-        success,
-        stdout: result?.stdout?.trim(),
-        stderr: result?.stderr?.trim(),
-        exitCode: result?.exitCode,
-        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
-      };
+    return fs4.realpathSync(p);
+  } catch {
+    const parent = path6.dirname(p);
+    try {
+      const realParent = fs4.realpathSync(parent);
+      return path6.join(realParent, path6.basename(p));
+    } catch {
+      return path6.resolve(p);
     }
-  } catch (error) {
-    console.error("Error while executing the terminal command", error);
+  }
+}
+function requireProjectCwd(toolName, projectCwd) {
+  if (!projectCwd && isMutatingTool(toolName)) {
     return {
-      success: false,
-      message: "Error while executing the terminal command",
-      error: error.message
+      allowed: false,
+      error: `ACCESS_DENIED: Tool "${toolName}" requires a project context (projectCwd) but none was provided`
     };
   }
-};
-var REGISTRY_FILE = path10.join(AMA_DIR, "projects.json");
+  return { allowed: true };
+}
+
+// src/lib/project-registry.ts
+var REGISTRY_FILE = path6.join(AMA_DIR, "projects.json");
 var ProjectRegistry = class {
   projects = /* @__PURE__ */ new Map();
   constructor() {
@@ -2075,14 +128,14 @@ var ProjectRegistry = class {
   }
   load() {
     try {
-      if (fs8.existsSync(REGISTRY_FILE)) {
-        const data = fs8.readFileSync(REGISTRY_FILE, "utf8");
+      if (fs4.existsSync(REGISTRY_FILE)) {
+        const data = fs4.readFileSync(REGISTRY_FILE, "utf8");
         const parsed = JSON.parse(data);
         if (!Array.isArray(parsed)) {
           console.error("Invalid project registry format: expected array, got", typeof parsed);
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs8.copyFileSync(REGISTRY_FILE, backupFile);
-          fs8.unlinkSync(REGISTRY_FILE);
+          fs4.copyFileSync(REGISTRY_FILE, backupFile);
+          fs4.unlinkSync(REGISTRY_FILE);
           return;
         }
         const projects = parsed;
@@ -2095,11 +148,11 @@ var ProjectRegistry = class {
       }
     } catch (error) {
       console.error("Failed to load project registry:", error);
-      if (fs8.existsSync(REGISTRY_FILE)) {
+      if (fs4.existsSync(REGISTRY_FILE)) {
         try {
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs8.copyFileSync(REGISTRY_FILE, backupFile);
-          fs8.unlinkSync(REGISTRY_FILE);
+          fs4.copyFileSync(REGISTRY_FILE, backupFile);
+          fs4.unlinkSync(REGISTRY_FILE);
           console.log("Corrupted registry file backed up and removed. Starting fresh.");
         } catch (backupError) {
         }
@@ -2108,21 +161,21 @@ var ProjectRegistry = class {
   }
   save() {
     try {
-      if (!fs8.existsSync(AMA_DIR)) {
-        fs8.mkdirSync(AMA_DIR, { recursive: true });
+      if (!fs4.existsSync(AMA_DIR)) {
+        fs4.mkdirSync(AMA_DIR, { recursive: true });
       }
       const projects = Array.from(this.projects.values());
-      fs8.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
+      fs4.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
     } catch (error) {
       console.error("Failed to save project registry:", error);
     }
   }
   register(projectId, cwd, name) {
-    const normalizedCwd = path10.normalize(path10.resolve(cwd));
+    const normalizedCwd = path6.normalize(path6.resolve(cwd));
     this.projects.set(projectId, {
       id: projectId,
       cwd: normalizedCwd,
-      name: name || path10.basename(normalizedCwd),
+      name: name || path6.basename(normalizedCwd),
       active: true
     });
     this.save();
@@ -2155,33 +208,33 @@ var getContext = (dir, base = dir, allFiles = []) => {
   const filePath = readdirSync(dir, { withFileTypes: true });
   for (const file of filePath) {
     if (ignoreFiles.includes(file.name)) continue;
-    const fullPath = path10.join(dir, file.name);
+    const fullPath = path6.join(dir, file.name);
     if (file.isDirectory()) {
       getContext(fullPath, base, allFiles);
     } else {
-      allFiles.push(path10.relative(base, fullPath));
+      allFiles.push(path6.relative(base, fullPath));
     }
   }
   return allFiles;
 };
 var HOME = os3.homedir();
 var IDE_PROJECTS_PATHS = {
-  vscode: path10.join(HOME, ".vscode", "projects"),
-  cursor: path10.join(HOME, ".cursor", "projects"),
-  claude: path10.join(HOME, ".claude", "projects")
+  vscode: path6.join(HOME, ".vscode", "projects"),
+  cursor: path6.join(HOME, ".cursor", "projects"),
+  claude: path6.join(HOME, ".claude", "projects")
 };
 function getWorkspaceStoragePath(ide) {
   const platform = os3.platform();
   const appName = ide === "cursor" ? "Cursor" : "Code";
   const appNameLower = appName.toLowerCase();
   if (platform === "darwin") {
-    return path10.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
+    return path6.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
   } else if (platform === "win32") {
-    return path10.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
+    return path6.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
   } else {
-    const capitalizedPath = path10.join(HOME, ".config", appName, "User", "workspaceStorage");
-    const lowercasePath = path10.join(HOME, ".config", appNameLower, "User", "workspaceStorage");
-    if (fs8.existsSync(capitalizedPath)) {
+    const capitalizedPath = path6.join(HOME, ".config", appName, "User", "workspaceStorage");
+    const lowercasePath = path6.join(HOME, ".config", appNameLower, "User", "workspaceStorage");
+    if (fs4.existsSync(capitalizedPath)) {
       return capitalizedPath;
     }
     return lowercasePath;
@@ -2190,16 +243,16 @@ function getWorkspaceStoragePath(ide) {
 function scanWorkspaceStorage(ide) {
   const projects = [];
   const storagePath = getWorkspaceStoragePath(ide);
-  if (!fs8.existsSync(storagePath)) {
+  if (!fs4.existsSync(storagePath)) {
     return projects;
   }
   try {
-    const workspaces = fs8.readdirSync(storagePath);
+    const workspaces = fs4.readdirSync(storagePath);
     for (const workspace of workspaces) {
-      const workspaceJsonPath = path10.join(storagePath, workspace, "workspace.json");
-      if (fs8.existsSync(workspaceJsonPath)) {
+      const workspaceJsonPath = path6.join(storagePath, workspace, "workspace.json");
+      if (fs4.existsSync(workspaceJsonPath)) {
         try {
-          const content = fs8.readFileSync(workspaceJsonPath, "utf-8");
+          const content = fs4.readFileSync(workspaceJsonPath, "utf-8");
           const data = JSON.parse(content);
           if (data.folder && typeof data.folder === "string") {
             let projectPath = data.folder;
@@ -2207,9 +260,9 @@ function scanWorkspaceStorage(ide) {
               projectPath = projectPath.replace("file://", "");
               projectPath = decodeURIComponent(projectPath);
             }
-            if (fs8.existsSync(projectPath) && fs8.statSync(projectPath).isDirectory()) {
+            if (fs4.existsSync(projectPath) && fs4.statSync(projectPath).isDirectory()) {
               projects.push({
-                name: path10.basename(projectPath),
+                name: path6.basename(projectPath),
                 path: projectPath,
                 type: ide
               });
@@ -2231,11 +284,11 @@ var scanIdeProjects = async () => {
     const seenPaths = /* @__PURE__ */ new Set();
     const addProject = (projectPath, ide) => {
       try {
-        const resolvedPath = fs8.realpathSync(projectPath);
-        if (fs8.existsSync(resolvedPath) && fs8.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+        const resolvedPath = fs4.realpathSync(projectPath);
+        if (fs4.existsSync(resolvedPath) && fs4.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
           const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
             try {
-              return fs8.realpathSync(ideDir) === resolvedPath;
+              return fs4.realpathSync(ideDir) === resolvedPath;
             } catch {
               return false;
             }
@@ -2243,7 +296,7 @@ var scanIdeProjects = async () => {
           if (!isIdeProjectsDir) {
             seenPaths.add(resolvedPath);
             allProjects.push({
-              name: path10.basename(resolvedPath),
+              name: path6.basename(resolvedPath),
               path: resolvedPath,
               type: ide
             });
@@ -2262,30 +315,30 @@ var scanIdeProjects = async () => {
     }
     for (const [ide, dirPath] of Object.entries(IDE_PROJECTS_PATHS)) {
       if (ide === "cursor" || ide === "vscode") continue;
-      if (fs8.existsSync(dirPath)) {
-        const projects = fs8.readdirSync(dirPath);
+      if (fs4.existsSync(dirPath)) {
+        const projects = fs4.readdirSync(dirPath);
         projects.forEach((project) => {
-          const projectPath = path10.join(dirPath, project);
+          const projectPath = path6.join(dirPath, project);
           try {
-            const stats = fs8.lstatSync(projectPath);
+            const stats = fs4.lstatSync(projectPath);
             let actualPath = null;
             if (stats.isSymbolicLink()) {
-              actualPath = fs8.realpathSync(projectPath);
+              actualPath = fs4.realpathSync(projectPath);
             } else if (stats.isFile()) {
               try {
-                let content = fs8.readFileSync(projectPath, "utf-8").trim();
+                let content = fs4.readFileSync(projectPath, "utf-8").trim();
                 if (content.startsWith("~/") || content === "~") {
                   content = content.replace(/^~/, HOME);
                 }
-                const resolvedContent = path10.isAbsolute(content) ? content : path10.resolve(path10.dirname(projectPath), content);
-                if (fs8.existsSync(resolvedContent) && fs8.statSync(resolvedContent).isDirectory()) {
-                  actualPath = fs8.realpathSync(resolvedContent);
+                const resolvedContent = path6.isAbsolute(content) ? content : path6.resolve(path6.dirname(projectPath), content);
+                if (fs4.existsSync(resolvedContent) && fs4.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs4.realpathSync(resolvedContent);
                 }
               } catch {
                 return;
               }
             } else if (stats.isDirectory()) {
-              actualPath = fs8.realpathSync(projectPath);
+              actualPath = fs4.realpathSync(projectPath);
             }
             if (actualPath) {
               addProject(actualPath, ide);
@@ -2304,7 +357,7 @@ var scanIdeProjects = async () => {
 var Global;
 ((Global2) => {
   ((Path2) => {
-    Path2.data = path10.join(AMA_DIR, "data");
+    Path2.data = path6.join(AMA_DIR, "data");
   })(Global2.Path || (Global2.Path = {}));
 })(Global || (Global = {}));
 
@@ -2343,8 +396,8 @@ var Snapshot;
     const worktree = project.cwd;
     const git = gitdir(projectId);
     try {
-      await fsp__default.mkdir(git, { recursive: true });
-      const gitExists = await fsp__default.access(path10.join(git, "HEAD")).then(() => true).catch(() => false);
+      await fs5.mkdir(git, { recursive: true });
+      const gitExists = await fs5.access(path6.join(git, "HEAD")).then(() => true).catch(() => false);
       if (!gitExists) {
         await runGit(`git init`, {
           env: { GIT_DIR: git, GIT_WORK_TREE: worktree }
@@ -2385,7 +438,7 @@ var Snapshot;
     const files = result.stdout;
     return {
       hash,
-      files: files.trim().split("\n").map((x) => x.trim()).filter(Boolean).map((x) => path10.join(worktree, x))
+      files: files.trim().split("\n").map((x) => x.trim()).filter(Boolean).map((x) => path6.join(worktree, x))
     };
   }
   Snapshot2.patch = patch;
@@ -2427,9 +480,9 @@ var Snapshot;
       if (diffResult.exitCode === 0 && diffResult.stdout.trim()) {
         const newFiles = diffResult.stdout.trim().split("\n").filter(Boolean);
         for (const file of newFiles) {
-          const fullPath = path10.join(worktree, file);
+          const fullPath = path6.join(worktree, file);
           try {
-            await fsp__default.unlink(fullPath);
+            await fs5.unlink(fullPath);
             log.info("deleted newly created file", { file: fullPath });
           } catch {
           }
@@ -2457,7 +510,7 @@ var Snapshot;
           { cwd: worktree }
         );
         if (result.exitCode !== 0) {
-          const relativePath = path10.relative(worktree, file);
+          const relativePath = path6.relative(worktree, file);
           const checkTree = await runGit(
             `git --git-dir "${git}" --work-tree "${worktree}" ls-tree ${item.hash} -- "${relativePath}"`,
             { cwd: worktree }
@@ -2466,7 +519,7 @@ var Snapshot;
             log.info("file existed in snapshot but checkout failed, keeping", { file });
           } else {
             log.info("file did not exist in snapshot, deleting", { file });
-            await fsp__default.unlink(file).catch(() => {
+            await fs5.unlink(file).catch(() => {
             });
           }
         }
@@ -2520,10 +573,10 @@ var Snapshot;
     const lines = numstatResult.stdout.trim().split("\n").filter(Boolean);
     for (const line of lines) {
       const [additions, deletions, file] = line.split("	");
-      const isBinaryFile2 = additions === "-" && deletions === "-";
+      const isBinaryFile = additions === "-" && deletions === "-";
       let before = "";
       let after = "";
-      if (!isBinaryFile2) {
+      if (!isBinaryFile) {
         const beforeResult = await runGit(
           `git -c core.autocrlf=false --git-dir "${git}" --work-tree "${worktree}" show ${from}:${file}`,
           { cwd: worktree }
@@ -2547,13 +600,13 @@ var Snapshot;
   }
   Snapshot2.diffFull = diffFull;
   function gitdir(projectId) {
-    return path10.join(Global.Path.data, "snapshot", projectId);
+    return path6.join(Global.Path.data, "snapshot", projectId);
   }
 })(Snapshot || (Snapshot = {}));
 var CLIENT_ID2 = "app_EMoamEEZ73f0CkXaXp7hrann";
 var ISSUER = "https://auth.openai.com";
 var OAUTH_PORT = 1455;
-var CREDENTIALS_PATH2 = path10.join(AMA_DIR, "codex-credentials.json");
+var CREDENTIALS_PATH2 = path6.join(AMA_DIR, "codex-credentials.json");
 var CALLBACK_PATH = "/auth/callback";
 var OAUTH_TIMEOUT_MS = 5 * 60 * 1e3;
 var REFRESH_BUFFER_MS = 60 * 1e3;
@@ -2648,19 +701,19 @@ var HTML_ERROR = (error) => `<!doctype html>
   </body>
 </html>`;
 function ensureCredentialsDir() {
-  if (!fs8.existsSync(AMA_DIR)) {
-    fs8.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs4.existsSync(AMA_DIR)) {
+    fs4.mkdirSync(AMA_DIR, { recursive: true });
   }
 }
 function saveCredentials(credentials) {
   ensureCredentialsDir();
-  fs8.writeFileSync(CREDENTIALS_PATH2, JSON.stringify(credentials, null, 2), "utf8");
+  fs4.writeFileSync(CREDENTIALS_PATH2, JSON.stringify(credentials, null, 2), "utf8");
 }
 function readCredentials() {
-  if (!fs8.existsSync(CREDENTIALS_PATH2)) {
+  if (!fs4.existsSync(CREDENTIALS_PATH2)) {
     return null;
   }
-  const raw = fs8.readFileSync(CREDENTIALS_PATH2, "utf8");
+  const raw = fs4.readFileSync(CREDENTIALS_PATH2, "utf8");
   const parsed = JSON.parse(raw);
   if (typeof parsed.accessToken !== "string" || typeof parsed.refreshToken !== "string" || typeof parsed.accountId !== "string" || typeof parsed.expiresAt !== "number") {
     return null;
@@ -2768,56 +821,66 @@ async function startOAuthServer() {
   if (oauthServer) {
     return { redirectUri: `http://localhost:${OAUTH_PORT}${CALLBACK_PATH}` };
   }
-  oauthServer = Bun.serve({
-    port: OAUTH_PORT,
-    fetch(request) {
-      const url = new URL(request.url);
-      if (url.pathname !== CALLBACK_PATH) {
-        return new Response("Not found", { status: 404 });
-      }
-      const code = url.searchParams.get("code");
-      const state = url.searchParams.get("state");
-      const error = url.searchParams.get("error");
-      const errorDescription = url.searchParams.get("error_description");
-      if (error) {
-        const message = errorDescription || error;
-        pendingOAuth?.reject(new Error(message));
-        pendingOAuth = void 0;
-        return new Response(HTML_ERROR(message), {
-          headers: { "Content-Type": "text/html" }
-        });
-      }
-      if (!code) {
-        const message = "Missing authorization code";
-        pendingOAuth?.reject(new Error(message));
-        pendingOAuth = void 0;
-        return new Response(HTML_ERROR(message), {
-          status: 400,
-          headers: { "Content-Type": "text/html" }
-        });
-      }
-      if (!pendingOAuth || state !== pendingOAuth.state) {
-        const message = "Invalid state - potential CSRF attack";
-        pendingOAuth?.reject(new Error(message));
-        pendingOAuth = void 0;
-        return new Response(HTML_ERROR(message), {
-          status: 400,
-          headers: { "Content-Type": "text/html" }
-        });
-      }
-      const current = pendingOAuth;
+  oauthServer = createServer((req, res) => {
+    const requestUrl = new URL(req.url || "/", `http://localhost:${OAUTH_PORT}`);
+    if (requestUrl.pathname !== CALLBACK_PATH) {
+      res.statusCode = 404;
+      res.end("Not found");
+      return;
+    }
+    const code = requestUrl.searchParams.get("code");
+    const state = requestUrl.searchParams.get("state");
+    const error = requestUrl.searchParams.get("error");
+    const errorDescription = requestUrl.searchParams.get("error_description");
+    const sendHtml = (html, statusCode = 200) => {
+      res.statusCode = statusCode;
+      res.setHeader("Content-Type", "text/html");
+      res.end(html);
+    };
+    if (error) {
+      const message = errorDescription || error;
+      pendingOAuth?.reject(new Error(message));
       pendingOAuth = void 0;
-      exchangeCodeForTokens(code, `http://localhost:${OAUTH_PORT}${CALLBACK_PATH}`, current.pkce).then((tokens) => current.resolve(tokens)).catch((err) => current.reject(err));
-      return new Response(HTML_SUCCESS, {
-        headers: { "Content-Type": "text/html" }
-      });
+      sendHtml(HTML_ERROR(message));
+      return;
+    }
+    if (!code) {
+      const message = "Missing authorization code";
+      pendingOAuth?.reject(new Error(message));
+      pendingOAuth = void 0;
+      sendHtml(HTML_ERROR(message), 400);
+      return;
+    }
+    if (!pendingOAuth || state !== pendingOAuth.state) {
+      const message = "Invalid state - potential CSRF attack";
+      pendingOAuth?.reject(new Error(message));
+      pendingOAuth = void 0;
+      sendHtml(HTML_ERROR(message), 400);
+      return;
     }
+    const current = pendingOAuth;
+    pendingOAuth = void 0;
+    exchangeCodeForTokens(code, `http://localhost:${OAUTH_PORT}${CALLBACK_PATH}`, current.pkce).then((tokens) => current.resolve(tokens)).catch((err) => current.reject(err));
+    sendHtml(HTML_SUCCESS);
   });
+  try {
+    await new Promise((resolve, reject) => {
+      oauthServer?.once("error", reject);
+      oauthServer?.listen(OAUTH_PORT, "127.0.0.1", () => {
+        oauthServer?.off("error", reject);
+        resolve();
+      });
+    });
+  } catch (error) {
+    oauthServer?.close();
+    oauthServer = void 0;
+    throw error;
+  }
   return { redirectUri: `http://localhost:${OAUTH_PORT}${CALLBACK_PATH}` };
 }
 function stopOAuthServer() {
   if (oauthServer) {
-    oauthServer.stop();
+    oauthServer.close();
     oauthServer = void 0;
   }
 }
@@ -2936,8 +999,8 @@ async function getCodexStatus() {
 async function codexLogout() {
   pendingOAuth = void 0;
   stopOAuthServer();
-  if (fs8.existsSync(CREDENTIALS_PATH2)) {
-    fs8.unlinkSync(CREDENTIALS_PATH2);
+  if (fs4.existsSync(CREDENTIALS_PATH2)) {
+    fs4.unlinkSync(CREDENTIALS_PATH2);
   }
 }
 
@@ -3220,125 +1283,6 @@ var connectToUserStreams = async (serverUrl) => {
   return ws;
 };
 var toolCallSchema = z.object({
-  tool: z.string().describe("The name of the tool to execute"),
-  parameters: z.record(z.string(), z.unknown()).describe("Parameters for the tool")
-});
-z.object({
-  tool_calls: z.array(toolCallSchema).min(1, "Provide at least one tool call").max(25, "Maximum of 25 tools allowed in batch").describe("Array of tool calls to execute in parallel")
-});
-var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
-var MAX_CONCURRENCY = 5;
-var PER_CALL_TIMEOUT = 3e4;
-var MAX_BATCH_SIZE = 25;
-var batchableToolExecutors = {
-  deleteFile,
-  grep: grepTool,
-  glob: globTool,
-  listDirectory: list,
-  readFile: read_file,
-  bash: bashTool,
-  stringReplace: apply_patch,
-  editFile: editFiles
-};
-function withTimeout(promise, ms) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error(`BATCH_CALL_TIMEOUT: exceeded ${ms}ms`));
-    }, ms);
-    promise.then((v) => {
-      clearTimeout(timer);
-      resolve(v);
-    }).catch((e) => {
-      clearTimeout(timer);
-      reject(e);
-    });
-  });
-}
-async function runWithConcurrencyLimit(tasks, limit) {
-  const results = new Array(tasks.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < tasks.length) {
-      const idx = nextIndex++;
-      results[idx] = await tasks[idx]();
-    }
-  }
-  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
-}
-var batchTool = async function(input, projectCwd) {
-  const { tool_calls } = input;
-  const callsToExecute = tool_calls.slice(0, MAX_BATCH_SIZE);
-  const discardedCalls = tool_calls.slice(MAX_BATCH_SIZE);
-  const executeCall = async (call) => {
-    const start = performance.now();
-    try {
-      if (DISALLOWED_TOOLS.has(call.tool)) {
-        return {
-          tool: call.tool,
-          success: false,
-          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`,
-          durationMs: 0
-        };
-      }
-      const executor = batchableToolExecutors[call.tool];
-      if (!executor) {
-        const availableTools = Object.keys(batchableToolExecutors).join(", ");
-        return {
-          tool: call.tool,
-          success: false,
-          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`,
-          durationMs: 0
-        };
-      }
-      const result = await withTimeout(executor(call.parameters, projectCwd), PER_CALL_TIMEOUT);
-      const durationMs = Math.round(performance.now() - start);
-      return {
-        tool: call.tool,
-        success: result.success !== false,
-        result,
-        durationMs
-      };
-    } catch (error) {
-      const durationMs = Math.round(performance.now() - start);
-      const timedOut = error.message?.includes("BATCH_CALL_TIMEOUT");
-      return {
-        tool: call.tool,
-        success: false,
-        error: error.message || String(error),
-        durationMs,
-        timedOut
-      };
-    }
-  };
-  const tasks = callsToExecute.map(
-    (call) => () => executeCall(call)
-  );
-  const results = await runWithConcurrencyLimit(tasks, MAX_CONCURRENCY);
-  for (const call of discardedCalls) {
-    results.push({
-      tool: call.tool,
-      success: false,
-      error: `Maximum of ${MAX_BATCH_SIZE} tools allowed in batch`,
-      durationMs: 0
-    });
-  }
-  const successfulCalls = results.filter((r) => r.success).length;
-  const failedCalls = results.length - successfulCalls;
-  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
-
-Keep using the batch tool for optimal performance in your next response!`;
-  return {
-    success: failedCalls === 0,
-    message: outputMessage,
-    totalCalls: results.length,
-    successful: successfulCalls,
-    failed: failedCalls,
-    results
-  };
-};
-var toolCallSchema2 = z.object({
   type: z.literal("tool_call"),
   id: z.string(),
   tool: z.string(),
@@ -3361,7 +1305,7 @@ var TOOL_TIMEOUTS = {
 function getTimeoutForTool(tool) {
   return TOOL_TIMEOUTS[tool] ?? DEFAULT_TIMEOUT_MS;
 }
-function withTimeout2(promise, ms, tool) {
+function withTimeout(promise, ms, tool) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
       reject(new ToolTimeoutError(tool, ms));
@@ -3411,7 +1355,7 @@ async function executeTool(toolName, args, projectCwd, executors) {
   }
   try {
     const timeoutMs = getTimeoutForTool(toolName);
-    const result = await withTimeout2(executor(args, projectCwd), timeoutMs, toolName);
+    const result = await withTimeout(executor(args, projectCwd), timeoutMs, toolName);
     const durationMs = Math.round(performance.now() - start);
     return {
       success: result?.success !== false,
@@ -3438,7 +1382,7 @@ async function executeTool(toolName, args, projectCwd, executors) {
   }
 }
 function parseToolCall(raw) {
-  const result = toolCallSchema2.safeParse(raw);
+  const result = toolCallSchema.safeParse(raw);
   if (!result.success) {
     return new ValidationError(
       `Invalid tool_call payload: ${result.error.issues.map((i) => i.message).join(", ")}`