@ch4p/cli 0.3.0 → 0.3.3

package/dist/chunk-AW4NG3S5.js

@@ -0,0 +1,3413 @@
+import {
+  SecurityError,
+  ToolError
+} from "./chunk-YSCX2QQQ.js";
+
+// ../../packages/tools/dist/index.js
+import { spawn } from "child_process";
+import { resolve } from "path";
+import { stat, readdir } from "fs/promises";
+import { readFile, stat as stat2 } from "fs/promises";
+import { resolve as resolve2, extname } from "path";
+import { writeFile, mkdir } from "fs/promises";
+import { resolve as resolve3, dirname } from "path";
+import { stat as stat3, readFile as readFile2 } from "fs/promises";
+import { createHash } from "crypto";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { readdir as readdir2, stat as stat4, readFile as readFile4 } from "fs/promises";
+import { resolve as resolve5, join, relative, extname as extname2 } from "path";
+import { readdir as readdir3, stat as stat5 } from "fs/promises";
+import { resolve as resolve6, join as join2 } from "path";
+import { randomBytes } from "crypto";
+import { resolve4 as resolve42, resolve6 as resolve62 } from "dns/promises";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_MAX_OUTPUT_LENGTH = 3e4;
+var MAX_BASH_OUTPUT_BYTES = 10 * 1024 * 1024;
+var BashTool = class {
+  name = "bash";
+  description = "Execute a shell command. Commands are validated against the security policy. Output from stdout and stderr is captured and returned. Long-running commands can be cancelled via abort signal.";
+  weight = "heavyweight";
+  parameters = {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The shell command to execute.",
+        minLength: 1
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds. Defaults to 120000 (2 minutes).",
+        minimum: 1,
+        maximum: 6e5
+      },
+      cwd: {
+        type: "string",
+        description: "Working directory for the command. Defaults to the session working directory."
+      }
+    },
+    required: ["command"],
+    additionalProperties: false
+  };
+  activeProcess = null;
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { command, timeout, cwd } = args;
+    const errors = [];
+    if (typeof command !== "string" || command.trim().length === 0) {
+      errors.push("command must be a non-empty string.");
+    }
+    if (timeout !== void 0) {
+      if (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout < 1) {
+        errors.push("timeout must be a positive number.");
+      }
+      if (typeof timeout === "number" && timeout > 6e5) {
+        errors.push("timeout cannot exceed 600000ms (10 minutes).");
+      }
+    }
+    if (cwd !== void 0 && typeof cwd !== "string") {
+      errors.push("cwd must be a string.");
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const { command, timeout, cwd } = args;
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS;
+    const workingDir = cwd ? resolve(context.cwd, cwd) : context.cwd;
+    const cwdValidation = context.securityPolicy.validatePath(workingDir, "read");
+    if (!cwdValidation.allowed) {
+      throw new SecurityError(
+        `Working directory blocked: ${cwdValidation.reason ?? workingDir}`,
+        { path: workingDir }
+      );
+    }
+    const commandValidation = context.securityPolicy.validateCommand("bash", [
+      "-c",
+      command
+    ]);
+    if (!commandValidation.allowed) {
+      throw new SecurityError(
+        `Command blocked: ${commandValidation.reason ?? command}`,
+        { command }
+      );
+    }
+    if (context.abortSignal.aborted) {
+      return {
+        success: false,
+        output: "",
+        error: "Command aborted before execution."
+      };
+    }
+    return this.runCommand(command, workingDir, timeoutMs, context);
+  }
+  abort(_reason) {
+    if (this.activeProcess && !this.activeProcess.killed) {
+      this.activeProcess.kill("SIGTERM");
+      setTimeout(() => {
+        if (this.activeProcess && !this.activeProcess.killed) {
+          this.activeProcess.kill("SIGKILL");
+        }
+      }, 5e3);
+    }
+  }
+  runCommand(command, cwd, timeoutMs, context) {
+    return new Promise((resolvePromise) => {
+      const child = spawn("bash", ["-c", command], {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env }
+        // Close stdin immediately — we never write to it
+      });
+      this.activeProcess = child;
+      child.stdin?.end();
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      let totalBytes = 0;
+      let killed = false;
+      let outputCapped = false;
+      const killForOutputCap = () => {
+        if (outputCapped) return;
+        outputCapped = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) child.kill("SIGKILL");
+        }, 5e3);
+      };
+      child.stdout?.on("data", (chunk) => {
+        stdoutChunks.push(chunk);
+        totalBytes += chunk.length;
+        context.onProgress(`[stdout] ${chunk.toString("utf-8").trim()}`);
+        if (totalBytes > MAX_BASH_OUTPUT_BYTES) killForOutputCap();
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderrChunks.push(chunk);
+        totalBytes += chunk.length;
+        context.onProgress(`[stderr] ${chunk.toString("utf-8").trim()}`);
+        if (totalBytes > MAX_BASH_OUTPUT_BYTES) killForOutputCap();
+      });
+      const timer = setTimeout(() => {
+        killed = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill("SIGKILL");
+          }
+        }, 5e3);
+      }, timeoutMs);
+      const onAbort = () => {
+        killed = true;
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill("SIGKILL");
+          }
+        }, 5e3);
+      };
+      context.abortSignal.addEventListener("abort", onAbort, { once: true });
+      child.on("close", (code, signal) => {
+        clearTimeout(timer);
+        context.abortSignal.removeEventListener("abort", onAbort);
+        this.activeProcess = null;
+        const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+        let output = "";
+        if (stdout.length > 0) {
+          output += stdout;
+        }
+        if (stderr.length > 0) {
+          if (output.length > 0) output += "\n";
+          output += stderr;
+        }
+        if (output.length > DEFAULT_MAX_OUTPUT_LENGTH) {
+          const halfLen = Math.floor((DEFAULT_MAX_OUTPUT_LENGTH - 50) / 2);
+          output = output.slice(0, halfLen) + "\n\n... [output truncated] ...\n\n" + output.slice(output.length - halfLen);
+        }
+        if (outputCapped) {
+          resolvePromise({
+            success: false,
+            output,
+            error: `Command output exceeded ${MAX_BASH_OUTPUT_BYTES / 1024 / 1024}MiB limit and was killed.`,
+            metadata: { code, signal, outputCapped: true }
+          });
+          return;
+        }
+        if (killed && context.abortSignal.aborted) {
+          resolvePromise({
+            success: false,
+            output,
+            error: "Command was aborted.",
+            metadata: { code, signal }
+          });
+          return;
+        }
+        if (killed) {
+          resolvePromise({
+            success: false,
+            output,
+            error: `Command timed out after ${timeoutMs}ms.`,
+            metadata: { code, signal, timedOut: true }
+          });
+          return;
+        }
+        resolvePromise({
+          success: code === 0,
+          output,
+          error: code !== 0 ? `Command exited with code ${code}.` : void 0,
+          metadata: { code, signal }
+        });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        context.abortSignal.removeEventListener("abort", onAbort);
+        this.activeProcess = null;
+        resolvePromise({
+          success: false,
+          output: "",
+          error: `Failed to spawn command: ${err.message}`
+        });
+      });
+    });
+  }
+  async getStateSnapshot(args, context) {
+    const { command, cwd } = args ?? {};
+    const workingDir = cwd ? resolve(context.cwd, cwd) : context.cwd;
+    try {
+      const dirStats = await stat(workingDir);
+      const entries = dirStats.isDirectory() ? await readdir(workingDir).then((e) => e.length) : 0;
+      return {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        state: {
+          cwd: workingDir,
+          cwdExists: true,
+          entryCount: entries,
+          command: command?.slice(0, 200)
+        },
+        description: `Working directory state for bash: ${workingDir}`
+      };
+    } catch {
+      return {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        state: {
+          cwd: workingDir,
+          cwdExists: false,
+          command: command?.slice(0, 200)
+        },
+        description: `Working directory state for bash: ${workingDir} (does not exist)`
+      };
+    }
+  }
+};
+var DEFAULT_LINE_LIMIT = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".avif",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".flv",
+  ".wmv",
+  ".wav",
+  ".flac",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".sqlite",
+  ".db",
+  ".sqlite3",
+  ".class",
+  ".pyc",
+  ".pyo",
+  ".o",
+  ".obj",
+  ".wasm"
+]);
+var FileReadTool = class {
+  name = "file_read";
+  description = "Read the contents of a file from the filesystem. Lines are returned with line number prefixes. Supports offset and limit for reading portions of large files. Binary files are detected and rejected.";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Absolute or relative path to the file to read.",
+        minLength: 1
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-based). Defaults to 1.",
+        minimum: 1
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read. Defaults to 2000.",
+        minimum: 1
+      }
+    },
+    required: ["path"],
+    additionalProperties: false
+  };
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { path, offset, limit } = args;
+    const errors = [];
+    if (typeof path !== "string" || path.trim().length === 0) {
+      errors.push("path must be a non-empty string.");
+    }
+    if (offset !== void 0) {
+      if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 1) {
+        errors.push("offset must be a positive integer (1-based).");
+      }
+    }
+    if (limit !== void 0) {
+      if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1) {
+        errors.push("limit must be a positive integer.");
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const { path: filePath, offset, limit } = args;
+    const absolutePath = resolve2(context.cwd, filePath);
+    const pathValidation = context.securityPolicy.validatePath(absolutePath, "read");
+    if (!pathValidation.allowed) {
+      throw new SecurityError(
+        `Path blocked: ${pathValidation.reason ?? absolutePath}`,
+        { path: absolutePath }
+      );
+    }
+    const resolvedPath = pathValidation.canonicalPath ?? absolutePath;
+    const ext = extname(resolvedPath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext)) {
+      return {
+        success: false,
+        output: "",
+        error: `Cannot read binary file (${ext}). Use an appropriate tool for this file type.`,
+        metadata: { path: resolvedPath, extension: ext, binary: true }
+      };
+    }
+    let fileStats;
+    try {
+      fileStats = await stat2(resolvedPath);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        return {
+          success: false,
+          output: "",
+          error: `File not found: ${resolvedPath}`
+        };
+      }
+      return {
+        success: false,
+        output: "",
+        error: `Cannot access file: ${err.message}`
+      };
+    }
+    if (!fileStats.isFile()) {
+      return {
+        success: false,
+        output: "",
+        error: `Path is not a file: ${resolvedPath}. Use ls or glob for directories.`
+      };
+    }
+    let content;
+    try {
+      const buffer = await readFile(resolvedPath);
+      const sampleSize = Math.min(buffer.length, 8192);
+      for (let i = 0; i < sampleSize; i++) {
+        if (buffer[i] === 0) {
+          return {
+            success: false,
+            output: "",
+            error: "File appears to be binary (contains null bytes).",
+            metadata: { path: resolvedPath, size: fileStats.size, binary: true }
+          };
+        }
+      }
+      content = buffer.toString("utf-8");
+    } catch (err) {
+      return {
+        success: false,
+        output: "",
+        error: `Failed to read file: ${err.message}`
+      };
+    }
+    if (content.length === 0) {
+      return {
+        success: true,
+        output: "(empty file)",
+        metadata: { path: resolvedPath, lines: 0, size: 0 }
+      };
+    }
+    const allLines = content.split("\n");
+    const startLine = (offset ?? 1) - 1;
+    const lineLimit = limit ?? DEFAULT_LINE_LIMIT;
+    const endLine = Math.min(startLine + lineLimit, allLines.length);
+    const selectedLines = allLines.slice(startLine, endLine);
+    const maxLineNumWidth = String(endLine).length;
+    const formattedLines = selectedLines.map((line, idx) => {
+      const lineNum = String(startLine + idx + 1).padStart(maxLineNumWidth, " ");
+      const truncatedLine = line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + "...(truncated)" : line;
+      return `${lineNum}	${truncatedLine}`;
+    });
+    const output = formattedLines.join("\n");
+    const metadata = {
+      path: resolvedPath,
+      totalLines: allLines.length,
+      startLine: startLine + 1,
+      endLine,
+      size: fileStats.size
+    };
+    if (endLine < allLines.length) {
+      metadata.truncated = true;
+      metadata.remainingLines = allLines.length - endLine;
+    }
+    return {
+      success: true,
+      output,
+      metadata
+    };
+  }
+};
+async function captureFileState(absolutePath, description) {
+  try {
+    const fileStats = await stat3(absolutePath);
+    if (!fileStats.isFile()) {
+      return {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        state: {
+          path: absolutePath,
+          exists: true,
+          isFile: false,
+          isDirectory: fileStats.isDirectory()
+        },
+        description: description ?? `State of ${absolutePath}`
+      };
+    }
+    const MAX_HASH_SIZE = 1048576;
+    let contentHash;
+    let lineCount;
+    if (fileStats.size <= MAX_HASH_SIZE) {
+      const content = await readFile2(absolutePath, "utf-8");
+      contentHash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+      lineCount = content.split("\n").length;
+    } else {
+      const buffer = await readFile2(absolutePath);
+      contentHash = createHash("sha256").update(buffer.subarray(0, MAX_HASH_SIZE)).digest("hex").slice(0, 16);
+    }
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      state: {
+        path: absolutePath,
+        exists: true,
+        isFile: true,
+        size: fileStats.size,
+        mtime: fileStats.mtime.toISOString(),
+        contentHash,
+        ...lineCount !== void 0 ? { lineCount } : {}
+      },
+      description: description ?? `State of ${absolutePath}`
+    };
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        state: {
+          path: absolutePath,
+          exists: false
+        },
+        description: description ?? `State of ${absolutePath} (does not exist)`
+      };
+    }
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      state: {
+        path: absolutePath,
+        exists: void 0,
+        error: `Cannot access: ${err.message}`
+      },
+      description: description ?? `State of ${absolutePath} (error)`
+    };
+  }
+}
+var FileWriteTool = class {
+  name = "file_write";
+  description = "Write content to a file. Creates the file if it does not exist, or overwrites it if it does. Parent directories are created automatically. Path is validated against the security policy.";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Absolute or relative path to the file to write.",
+        minLength: 1
+      },
+      content: {
+        type: "string",
+        description: "The content to write to the file."
+      }
+    },
+    required: ["path", "content"],
+    additionalProperties: false
+  };
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { path, content } = args;
+    const errors = [];
+    if (typeof path !== "string" || path.trim().length === 0) {
+      errors.push("path must be a non-empty string.");
+    }
+    if (typeof content !== "string") {
+      errors.push("content must be a string.");
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const { path: filePath, content } = args;
+    const absolutePath = resolve3(context.cwd, filePath);
+    const pathValidation = context.securityPolicy.validatePath(absolutePath, "write");
+    if (!pathValidation.allowed) {
+      throw new SecurityError(
+        `Path blocked for writing: ${pathValidation.reason ?? absolutePath}`,
+        { path: absolutePath }
+      );
+    }
+    const resolvedPath = pathValidation.canonicalPath ?? absolutePath;
+    const parentDir = dirname(resolvedPath);
+    try {
+      await mkdir(parentDir, { recursive: true });
+    } catch (err) {
+      return {
+        success: false,
+        output: "",
+        error: `Failed to create parent directory: ${err.message}`
+      };
+    }
+    try {
+      await writeFile(resolvedPath, content, "utf-8");
+    } catch (err) {
+      return {
+        success: false,
+        output: "",
+        error: `Failed to write file: ${err.message}`
+      };
+    }
+    const lineCount = content.split("\n").length;
+    const byteCount = Buffer.byteLength(content, "utf-8");
+    return {
+      success: true,
+      output: `File written successfully: ${resolvedPath} (${lineCount} lines, ${byteCount} bytes)`,
+      metadata: {
+        path: resolvedPath,
+        lines: lineCount,
+        bytes: byteCount
+      }
+    };
+  }
+  async getStateSnapshot(args, context) {
+    const { path: filePath } = args ?? {};
+    if (!filePath) {
+      return {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        state: { error: "No path argument provided" }
+      };
+    }
+    const absolutePath = resolve3(context.cwd, filePath);
+    return captureFileState(absolutePath);
+  }
+};
+var FileEditTool = class {
+  name = "file_edit";
+  description = "Perform exact string replacements in a file. The old_string must be unique in the file unless replace_all is set to true. This ensures edits are unambiguous. The new_string must differ from old_string.";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Absolute or relative path to the file to edit.",
+        minLength: 1
+      },
+      old_string: {
+        type: "string",
+        description: "The exact string to find and replace."
+      },
+      new_string: {
+        type: "string",
+        description: "The replacement string."
+      },
+      replace_all: {
+        type: "boolean",
+        description: "If true, replace all occurrences. If false (default), old_string must be unique.",
+        default: false
+      }
+    },
+    required: ["path", "old_string", "new_string"],
+    additionalProperties: false
+  };
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { path, old_string, new_string, replace_all } = args;
+    const errors = [];
+    if (typeof path !== "string" || path.trim().length === 0) {
+      errors.push("path must be a non-empty string.");
+    }
+    if (typeof old_string !== "string") {
+      errors.push("old_string must be a string.");
+    }
+    if (typeof new_string !== "string") {
+      errors.push("new_string must be a string.");
+    }
+    if (typeof old_string === "string" && typeof new_string === "string" && old_string === new_string) {
+      errors.push("new_string must be different from old_string.");
+    }
+    if (replace_all !== void 0 && typeof replace_all !== "boolean") {
+      errors.push("replace_all must be a boolean.");
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const {
+      path: filePath,
+      old_string: oldString,
+      new_string: newString,
+      replace_all: replaceAll = false
+    } = args;
+    const absolutePath = resolve4(context.cwd, filePath);
+    const pathValidation = context.securityPolicy.validatePath(absolutePath, "write");
+    if (!pathValidation.allowed) {
+      throw new SecurityError(
+        `Path blocked for writing: ${pathValidation.reason ?? absolutePath}`,
+        { path: absolutePath }
+      );
+    }
+    const resolvedPath = pathValidation.canonicalPath ?? absolutePath;
+    let content;
+    try {
+      content = await readFile3(resolvedPath, "utf-8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        return {
+          success: false,
+          output: "",
+          error: `File not found: ${resolvedPath}`
+        };
+      }
+      return {
+        success: false,
+        output: "",
+        error: `Failed to read file: ${err.message}`
+      };
+    }
+    const occurrences = countOccurrences(content, oldString);
+    if (occurrences === 0) {
+      return {
+        success: false,
+        output: "",
+        error: "old_string was not found in the file. Ensure you have the exact string including whitespace and indentation.",
+        metadata: { path: resolvedPath }
+      };
+    }
+    if (!replaceAll && occurrences > 1) {
+      return {
+        success: false,
+        output: "",
+        error: `old_string appears ${occurrences} times in the file. Provide more surrounding context to make it unique, or set replace_all to true.`,
+        metadata: { path: resolvedPath, occurrences }
+      };
+    }
+    let newContent;
+    let replacedCount;
+    if (replaceAll) {
+      newContent = content.split(oldString).join(newString);
+      replacedCount = occurrences;
+    } else {
+      const idx = content.indexOf(oldString);
+      newContent = content.slice(0, idx) + newString + content.slice(idx + oldString.length);
+      replacedCount = 1;
+    }
+    try {
+      await writeFile2(resolvedPath, newContent, "utf-8");
+    } catch (err) {
+      return {
+        success: false,
+        output: "",
+        error: `Failed to write file: ${err.message}`
+      };
+    }
+    return {
+      success: true,
+      output: `Replaced ${replacedCount} occurrence${replacedCount > 1 ? "s" : ""} in ${resolvedPath}.`,
+      metadata: {
+        path: resolvedPath,
+        replacements: replacedCount
+      }
+    };
+  }
+  async getStateSnapshot(args, context) {
+    const { path: filePath } = args ?? {};
+    if (!filePath) {
+      return {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        state: { error: "No path argument provided" }
+      };
+    }
+    const absolutePath = resolve4(context.cwd, filePath);
+    return captureFileState(absolutePath);
+  }
+};
+function countOccurrences(haystack, needle) {
+  if (needle.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    pos = haystack.indexOf(needle, pos);
+    if (pos === -1) break;
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+var MAX_RESULTS = 500;
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".avif",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".mkv",
+  ".wav",
+  ".flac",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".sqlite",
+  ".db",
+  ".sqlite3",
+  ".class",
+  ".pyc",
+  ".o",
+  ".obj",
+  ".wasm"
+]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".tox",
+  ".venv",
+  "venv",
+  ".cache",
+  "coverage"
+]);
+var GrepTool = class {
+  name = "grep";
+  description = "Search file contents using regular expressions. Supports glob pattern filtering, multiple output modes (content, files_with_matches, count), and context lines around matches.";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regular expression pattern to search for.",
+        minLength: 1
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in. Defaults to the session working directory."
+      },
+      glob: {
+        type: "string",
+        description: 'Glob pattern to filter files (e.g. "*.ts", "*.{js,jsx}"). Only files matching this pattern are searched.'
+      },
+      output_mode: {
+        type: "string",
+        enum: ["content", "files_with_matches", "count"],
+        description: 'Output mode: "content" shows matching lines, "files_with_matches" shows file paths (default), "count" shows match counts.',
+        default: "files_with_matches"
+      },
+      context_lines: {
+        type: "number",
+        description: 'Number of context lines to show before and after each match. Only used with output_mode "content".',
+        minimum: 0,
+        maximum: 20
+      }
+    },
+    required: ["pattern"],
+    additionalProperties: false
+  };
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { pattern, path, glob, output_mode, context_lines } = args;
+    const errors = [];
+    if (typeof pattern !== "string" || pattern.trim().length === 0) {
+      errors.push("pattern must be a non-empty string.");
+    }
+    if (typeof pattern === "string") {
+      try {
+        new RegExp(pattern);
+      } catch {
+        errors.push(`Invalid regular expression: ${pattern}`);
+      }
+    }
+    if (path !== void 0 && typeof path !== "string") {
+      errors.push("path must be a string.");
+    }
+    if (glob !== void 0 && typeof glob !== "string") {
+      errors.push("glob must be a string.");
+    }
+    if (output_mode !== void 0 && !["content", "files_with_matches", "count"].includes(output_mode)) {
+      errors.push('output_mode must be "content", "files_with_matches", or "count".');
+    }
+    if (context_lines !== void 0) {
+      if (typeof context_lines !== "number" || !Number.isInteger(context_lines) || context_lines < 0) {
+        errors.push("context_lines must be a non-negative integer.");
+      }
+      if (typeof context_lines === "number" && context_lines > 20) {
+        errors.push("context_lines cannot exceed 20.");
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const {
+      pattern,
+      path: searchPath,
+      glob: globPattern,
+      output_mode: outputMode = "files_with_matches",
+      context_lines: contextLines = 0
+    } = args;
+    const regex = new RegExp(pattern, "g");
+    const basePath = searchPath ? resolve5(context.cwd, searchPath) : context.cwd;
+    const pathValidation = context.securityPolicy.validatePath(basePath, "read");
+    if (!pathValidation.allowed) {
+      throw new SecurityError(
+        `Search path blocked: ${pathValidation.reason ?? basePath}`,
+        { path: basePath }
+      );
+    }
+    const resolvedBase = pathValidation.canonicalPath ?? basePath;
+    let fileStat;
+    try {
+      fileStat = await stat4(resolvedBase);
+    } catch {
+      return {
+        success: false,
+        output: "",
+        error: `Path not found: ${resolvedBase}`
+      };
+    }
+    const files = [];
+    if (fileStat.isFile()) {
+      files.push(resolvedBase);
+    } else if (fileStat.isDirectory()) {
+      await collectFiles(resolvedBase, files, globPattern, context);
+    } else {
+      return {
+        success: false,
+        output: "",
+        error: `Path is not a file or directory: ${resolvedBase}`
+      };
+    }
+    const mode = outputMode;
+    const results = [];
+    let totalMatches = 0;
+    let filesWithMatches = 0;
+    let resultLimitReached = false;
+    for (const file of files) {
+      if (context.abortSignal.aborted) break;
+      if (resultLimitReached) break;
+      const matches = await searchFile(file, regex, mode, contextLines);
+      if (matches === null) continue;
+      if (matches.matchCount > 0) {
+        filesWithMatches++;
+        totalMatches += matches.matchCount;
+        const relPath = relative(context.cwd, file);
+        switch (mode) {
+          case "files_with_matches":
+            results.push(relPath);
+            break;
+          case "count":
+            results.push(`${relPath}:${matches.matchCount}`);
+            break;
+          case "content":
+            for (const line of matches.lines) {
+              results.push(`${relPath}:${line}`);
+              if (results.length >= MAX_RESULTS) {
+                resultLimitReached = true;
+                break;
+              }
+            }
+            break;
+        }
+        if (results.length >= MAX_RESULTS) {
+          resultLimitReached = true;
+        }
+      }
+    }
+    if (results.length === 0) {
+      return {
+        success: true,
+        output: "No matches found.",
+        metadata: { pattern, filesSearched: files.length, matches: 0 }
+      };
+    }
+    let output = results.join("\n");
+    if (resultLimitReached) {
+      output += `
+
+(results truncated at ${MAX_RESULTS} entries)`;
+    }
+    return {
+      success: true,
+      output,
+      metadata: {
+        pattern,
+        filesSearched: files.length,
+        filesWithMatches,
+        totalMatches,
+        truncated: resultLimitReached
+      }
+    };
+  }
+};
+async function collectFiles(dir, files, globPattern, context) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (context.abortSignal.aborted) return;
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const dirValidation = context.securityPolicy.validatePath(fullPath, "read");
+      if (!dirValidation.allowed) continue;
+      await collectFiles(fullPath, files, globPattern, context);
+    } else if (entry.isFile()) {
+      const ext = extname2(entry.name).toLowerCase();
+      if (SKIP_EXTENSIONS.has(ext)) continue;
+      if (globPattern && !matchGlob(entry.name, globPattern)) continue;
+      files.push(fullPath);
+    }
+  }
+}
+function matchGlob(filename, pattern) {
+  const expanded = expandBraces(pattern);
+  return expanded.some((p) => matchSimpleGlob(filename, p));
+}
+function matchSimpleGlob(str, pattern) {
+  let regexStr = "^";
+  for (let i = 0; i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        regexStr += ".*";
+        i++;
+        if (pattern[i + 1] === "/") i++;
+      } else {
+        regexStr += "[^/]*";
+      }
+    } else if (c === "?") {
+      regexStr += "[^/]";
+    } else if (c === ".") {
+      regexStr += "\\.";
+    } else {
+      regexStr += c;
+    }
+  }
+  regexStr += "$";
+  try {
+    return new RegExp(regexStr, "i").test(str);
+  } catch {
+    return false;
+  }
+}
+function expandBraces(pattern) {
+  const braceStart = pattern.indexOf("{");
+  if (braceStart === -1) return [pattern];
+  const braceEnd = pattern.indexOf("}", braceStart);
+  if (braceEnd === -1) return [pattern];
+  const prefix = pattern.slice(0, braceStart);
+  const suffix = pattern.slice(braceEnd + 1);
+  const alternatives = pattern.slice(braceStart + 1, braceEnd).split(",");
+  const results = [];
+  for (const alt of alternatives) {
+    results.push(...expandBraces(prefix + alt.trim() + suffix));
+  }
+  return results;
+}
+async function searchFile(filePath, regex, mode, contextLines) {
+  let fileSize;
+  try {
+    const stats = await stat4(filePath);
+    fileSize = stats.size;
+  } catch {
+    return null;
+  }
+  if (fileSize > MAX_FILE_SIZE) return null;
+  let content;
+  try {
+    const buffer = await readFile4(filePath);
+    const sampleSize = Math.min(buffer.length, 512);
+    for (let i = 0; i < sampleSize; i++) {
+      if (buffer[i] === 0) return null;
+    }
+    content = buffer.toString("utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split("\n");
+  const matchingLineIndices = [];
+  for (let i = 0; i < lines.length; i++) {
+    regex.lastIndex = 0;
+    if (regex.test(lines[i])) {
+      matchingLineIndices.push(i);
+    }
+  }
+  if (matchingLineIndices.length === 0) {
+    return { matchCount: 0, lines: [] };
+  }
+  if (mode === "files_with_matches" || mode === "count") {
+    return { matchCount: matchingLineIndices.length, lines: [] };
+  }
+  const outputLines = [];
+  const includedLines = /* @__PURE__ */ new Set();
+  for (const matchIdx of matchingLineIndices) {
+    const start = Math.max(0, matchIdx - contextLines);
+    const end = Math.min(lines.length - 1, matchIdx + contextLines);
+    if (outputLines.length > 0 && !includedLines.has(start - 1)) {
+      outputLines.push("--");
+    }
+    for (let i = start; i <= end; i++) {
+      if (includedLines.has(i)) continue;
+      includedLines.add(i);
+      const lineNum = i + 1;
+      const separator = i === matchIdx ? ":" : "-";
+      outputLines.push(`${lineNum}${separator}${lines[i]}`);
+    }
+  }
+  return { matchCount: matchingLineIndices.length, lines: outputLines };
+}
+var MAX_RESULTS2 = 1e3;
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  ".next",
+  "__pycache__",
+  ".tox",
+  ".venv",
+  "venv",
+  ".cache",
+  "coverage"
+]);
+var GlobTool = class {
+  name = "glob";
+  description = "Find files matching a glob pattern. Supports standard glob syntax including *, **, ?, and {a,b} brace expansion. Results are sorted by modification time (most recent first).";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: 'Glob pattern to match files (e.g. "**/*.ts", "src/**/*.{js,jsx}").',
+        minLength: 1
+      },
+      path: {
+        type: "string",
+        description: "Directory to search in. Defaults to the session working directory."
+      }
+    },
+    required: ["pattern"],
+    additionalProperties: false
+  };
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { pattern, path } = args;
+    const errors = [];
+    if (typeof pattern !== "string" || pattern.trim().length === 0) {
+      errors.push("pattern must be a non-empty string.");
+    }
+    if (path !== void 0 && typeof path !== "string") {
+      errors.push("path must be a string.");
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const { pattern, path: searchPath } = args;
+    const basePath = searchPath ? resolve6(context.cwd, searchPath) : context.cwd;
+    const pathValidation = context.securityPolicy.validatePath(basePath, "read");
+    if (!pathValidation.allowed) {
+      throw new SecurityError(
+        `Search path blocked: ${pathValidation.reason ?? basePath}`,
+        { path: basePath }
+      );
+    }
+    const resolvedBase = pathValidation.canonicalPath ?? basePath;
+    const patternParts = pattern.split("/");
+    const matcher = compileGlobPattern(pattern);
+    const matches = [];
+    await collectMatches(
+      resolvedBase,
+      "",
+      patternParts,
+      matcher,
+      matches,
+      context
+    );
+    if (matches.length === 0) {
+      return {
+        success: true,
+        output: "No files matched the pattern.",
+        metadata: { pattern, basePath: resolvedBase, matches: 0 }
+      };
+    }
+    matches.sort((a, b) => b.mtime - a.mtime);
+    const truncated = matches.length > MAX_RESULTS2;
+    const displayMatches = truncated ? matches.slice(0, MAX_RESULTS2) : matches;
+    let output = displayMatches.map((m) => m.path).join("\n");
+    if (truncated) {
+      output += `
+
+(showing ${MAX_RESULTS2} of ${matches.length} matches)`;
+    }
+    return {
+      success: true,
+      output,
+      metadata: {
+        pattern,
+        basePath: resolvedBase,
+        matches: matches.length,
+        truncated
+      }
+    };
+  }
+};
+async function collectMatches(basePath, relativePath, patternParts, matcher, matches, context) {
+  if (context.abortSignal.aborted) return;
+  if (matches.length >= MAX_RESULTS2 * 2) return;
+  const currentDir = join2(basePath, relativePath);
+  let entries;
+  try {
+    entries = await readdir3(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (context.abortSignal.aborted) return;
+    const entryRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+    const entryFull = join2(basePath, entryRelative);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS2.has(entry.name)) continue;
+      const dirValidation = context.securityPolicy.validatePath(entryFull, "read");
+      if (!dirValidation.allowed) continue;
+      await collectMatches(
+        basePath,
+        entryRelative,
+        patternParts,
+        matcher,
+        matches,
+        context
+      );
+    } else if (entry.isFile() || entry.isSymbolicLink()) {
+      if (matcher(entryRelative)) {
+        try {
+          const fileStat = await stat5(entryFull);
+          matches.push({
+            path: entryFull,
+            mtime: fileStat.mtimeMs
+          });
+        } catch {
+        }
+      }
+    }
+  }
+}
+function compileGlobPattern(pattern) {
+  const expanded = expandBraces2(pattern);
+  const regexes = expanded.map(globToRegex);
+  return (path) => regexes.some((re) => re.test(path));
+}
+function globToRegex(pattern) {
+  let regexStr = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/") {
+          regexStr += "(?:.+/)?";
+          i += 3;
+        } else {
+          regexStr += ".*";
+          i += 2;
+        }
+      } else {
+        regexStr += "[^/]*";
+        i++;
+      }
+    } else if (c === "?") {
+      regexStr += "[^/]";
+      i++;
+    } else if (c === ".") {
+      regexStr += "\\.";
+      i++;
+    } else if (c === "(" || c === ")" || c === "+" || c === "^" || c === "$" || c === "|") {
+      regexStr += "\\" + c;
+      i++;
+    } else if (c === "[") {
+      const closeBracket = pattern.indexOf("]", i + 1);
+      if (closeBracket === -1) {
+        regexStr += "\\[";
+        i++;
+      } else {
+        regexStr += pattern.slice(i, closeBracket + 1);
+        i = closeBracket + 1;
+      }
+    } else {
+      regexStr += c;
+      i++;
+    }
+  }
+  regexStr += "$";
+  try {
+    return new RegExp(regexStr);
+  } catch {
+    return /(?!)/;
+  }
+}
+function expandBraces2(pattern) {
+  const braceStart = pattern.indexOf("{");
+  if (braceStart === -1) return [pattern];
+  const braceEnd = pattern.indexOf("}", braceStart);
+  if (braceEnd === -1) return [pattern];
+  const prefix = pattern.slice(0, braceStart);
+  const suffix = pattern.slice(braceEnd + 1);
+  const alternatives = pattern.slice(braceStart + 1, braceEnd).split(",");
+  const results = [];
+  for (const alt of alternatives) {
+    results.push(...expandBraces2(prefix + alt.trim() + suffix));
+  }
+  return results;
+}
+var BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
+  "169.254.169.254",
+  // AWS / GCP / Azure instance metadata
+  "metadata.google.internal",
+  // GCP metadata alternative
+  "metadata.internal"
+  // Generic cloud metadata
+]);
+function isPrivateIpV4(ip) {
+  const parts = ip.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((p) => isNaN(p) || p < 0 || p > 255)) {
+    return true;
+  }
+  const [a, b] = parts;
+  if (a === 127) return true;
+  if (a === 10) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 0) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
+  if (a === 192 && b === 0) return true;
+  if (a === 198 && b === 51) return true;
+  if (a === 203 && b === 0) return true;
+  if (a >= 224) return true;
+  return false;
+}
+function isPrivateIpV6(ip) {
+  const lower = ip.toLowerCase();
+  if (lower === "::1" || lower === "::") return true;
+  if (lower === "0:0:0:0:0:0:0:1" || lower === "0:0:0:0:0:0:0:0") return true;
+  const v4MappedHex = lower.match(/^::ffff:([0-9a-f]+):([0-9a-f]+)$/);
+  if (v4MappedHex) {
+    const hi = parseInt(v4MappedHex[1], 16);
+    const lo = parseInt(v4MappedHex[2], 16);
+    const a = hi >> 8 & 255;
+    const b = hi & 255;
+    const c = lo >> 8 & 255;
+    const d = lo & 255;
+    if (isPrivateIpV4(`${a}.${b}.${c}.${d}`)) return true;
+  }
+  if (lower.startsWith("fe80:")) return true;
+  if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
+  const v4Mapped = lower.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  if (v4Mapped) {
+    return isPrivateIpV4(v4Mapped[1]);
+  }
+  return false;
+}
+function isBlockedHostname(hostname) {
+  if (BLOCKED_HOSTNAMES.has(hostname)) return true;
+  if (hostname === "localhost") return true;
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname)) {
+    return isPrivateIpV4(hostname);
+  }
+  if (hostname.includes(":")) {
+    return isPrivateIpV6(hostname);
+  }
+  return false;
+}
+async function resolveAndCheckPrivate(hostname) {
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname) || hostname.includes(":")) {
+    return { blocked: false };
+  }
+  try {
+    const [v4Addrs, v6Addrs] = await Promise.all([
+      resolve42(hostname).catch(() => []),
+      resolve62(hostname).catch(() => [])
+    ]);
+    for (const addr of v4Addrs) {
+      if (isPrivateIpV4(addr)) {
+        return { blocked: true, reason: `DNS resolved to private IPv4 address ${addr}` };
+      }
+    }
+    for (const addr of v6Addrs) {
+      if (isPrivateIpV6(addr)) {
+        return { blocked: true, reason: `DNS resolved to private IPv6 address ${addr}` };
+      }
+    }
+    if (v4Addrs.length === 0 && v6Addrs.length === 0) {
+      return { blocked: true, reason: `DNS resolution failed for ${hostname}` };
+    }
+    return { blocked: false };
+  } catch {
+    return { blocked: true, reason: `DNS resolution failed for ${hostname}` };
+  }
+}
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+var MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+var MAX_OUTPUT_LENGTH = 5e4;
+var MAX_REDIRECTS = 5;
+var WebFetchTool = class {
+  name = "web_fetch";
+  description = "Fetch content from a URL. HTML is converted to plain text. Supports HTTP and HTTPS. An optional prompt can describe what information to focus on in the response.";
+  weight = "heavyweight";
+  parameters = {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to fetch content from. Must be a valid HTTP or HTTPS URL.",
+        format: "uri",
+        minLength: 1
+      },
+      prompt: {
+        type: "string",
+        description: "Optional prompt describing what information to extract from the page."
+      }
+    },
+    required: ["url"],
+    additionalProperties: false
+  };
+  abortController = null;
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { url, prompt } = args;
+    const errors = [];
+    if (typeof url !== "string" || url.trim().length === 0) {
+      errors.push("url must be a non-empty string.");
+    }
+    if (typeof url === "string") {
+      try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+          errors.push("url must use http or https protocol.");
+        }
+        if (isBlockedHostname(parsed.hostname)) {
+          errors.push("url targets a blocked or private network address.");
+        }
+      } catch {
+        errors.push("url must be a valid URL.");
+      }
+    }
+    if (prompt !== void 0 && typeof prompt !== "string") {
+      errors.push("prompt must be a string.");
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const { url, prompt } = args;
+    let fetchUrl = url.replace(/^http:\/\//, "https://");
+    if (context.abortSignal.aborted) {
+      return {
+        success: false,
+        output: "",
+        error: "Request aborted before execution."
+      };
+    }
+    try {
+      const parsed = new URL(fetchUrl);
+      const dnsCheck = await resolveAndCheckPrivate(parsed.hostname);
+      if (dnsCheck.blocked) {
+        return {
+          success: false,
+          output: "",
+          error: `SSRF blocked: ${dnsCheck.reason}`,
+          metadata: { url: fetchUrl, ssrfBlocked: true }
+        };
+      }
+    } catch {
+      return {
+        success: false,
+        output: "",
+        error: "Failed to parse URL for SSRF check.",
+        metadata: { url: fetchUrl }
+      };
+    }
+    this.abortController = new AbortController();
+    const onContextAbort = () => this.abortController?.abort();
+    context.abortSignal.addEventListener("abort", onContextAbort, { once: true });
+    const timeoutId = setTimeout(() => {
+      this.abortController?.abort();
+    }, DEFAULT_TIMEOUT_MS2);
+    try {
+      context.onProgress(`Fetching ${fetchUrl}...`);
+      let response = null;
+      let redirectCount = 0;
+      while (redirectCount <= MAX_REDIRECTS) {
+        response = await fetch(fetchUrl, {
+          signal: this.abortController.signal,
+          headers: {
+            "User-Agent": "ch4p/0.1.0",
+            Accept: "text/html, application/json, text/plain, */*"
+          },
+          redirect: "manual"
+          // We follow redirects ourselves for SSRF safety.
+        });
+        const status = response.status;
+        if (status >= 300 && status < 400) {
+          const location = response.headers.get("location");
+          if (!location) break;
+          const redirectUrl = new URL(location, fetchUrl).toString();
+          const redirectParsed = new URL(redirectUrl);
+          if (isBlockedHostname(redirectParsed.hostname)) {
+            return {
+              success: false,
+              output: "",
+              error: `SSRF blocked: redirect to private/blocked address ${redirectParsed.hostname}`,
+              metadata: { url: fetchUrl, redirectUrl, ssrfBlocked: true }
+            };
+          }
+          const redirectDns = await resolveAndCheckPrivate(redirectParsed.hostname);
+          if (redirectDns.blocked) {
+            return {
+              success: false,
+              output: "",
+              error: `SSRF blocked on redirect: ${redirectDns.reason}`,
+              metadata: { url: fetchUrl, redirectUrl, ssrfBlocked: true }
+            };
+          }
+          fetchUrl = redirectUrl;
+          redirectCount++;
+          continue;
+        }
+        break;
+      }
+      if (!response) {
+        return {
+          success: false,
+          output: "",
+          error: "Failed to obtain a response.",
+          metadata: { url: fetchUrl }
+        };
+      }
+      if (redirectCount > MAX_REDIRECTS) {
+        return {
+          success: false,
+          output: "",
+          error: `Too many redirects (${MAX_REDIRECTS} max).`,
+          metadata: { url: fetchUrl, redirectCount }
+        };
+      }
+      if (response.status === 402) {
+        const payResult = await this.tryX402Payment(response, context);
+        if (!payResult.headerValue) {
+          return {
+            success: false,
+            output: "",
+            error: payResult.error ?? "Payment required (x402). Configure x402.client.privateKey to enable auto-payment.",
+            metadata: { url: fetchUrl, status: 402, x402Required: true }
+          };
+        }
+        context.onProgress("Paying x402 fee and retrying...");
+        const retryResponse = await fetch(fetchUrl, {
+          signal: this.abortController.signal,
+          redirect: "manual",
+          headers: {
+            "User-Agent": "ch4p/0.1.0",
+            Accept: "text/html, application/json, text/plain, */*",
+            "X-PAYMENT": payResult.headerValue
+          }
+        });
+        if (retryResponse.status >= 300 && retryResponse.status < 400) {
+          return {
+            success: false,
+            output: "",
+            error: `Unexpected redirect (${retryResponse.status}) after x402 payment. Blocked for SSRF safety.`,
+            metadata: { url: fetchUrl, status: retryResponse.status, x402Paid: true }
+          };
+        }
+        if (!retryResponse.ok) {
+          return {
+            success: false,
+            output: "",
+            error: `HTTP ${retryResponse.status} after x402 payment: ${retryResponse.statusText}`,
+            metadata: { url: fetchUrl, status: retryResponse.status, x402Paid: true }
+          };
+        }
+        response = retryResponse;
+      }
+      if (!response.ok) {
+        return {
+          success: false,
+          output: "",
+          error: `HTTP ${response.status}: ${response.statusText}`,
+          metadata: {
+            url: fetchUrl,
+            status: response.status,
+            statusText: response.statusText
+          }
+        };
+      }
+      const contentLength = response.headers.get("content-length");
+      if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE) {
+        return {
+          success: false,
+          output: "",
+          error: `Response too large: ${contentLength} bytes (limit: ${MAX_RESPONSE_SIZE}).`,
+          metadata: { url: fetchUrl, contentLength: parseInt(contentLength, 10) }
+        };
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const body = await response.text();
+      if (body.length > MAX_RESPONSE_SIZE) {
+        return {
+          success: false,
+          output: "",
+          error: `Response body too large: ${body.length} bytes (limit: ${MAX_RESPONSE_SIZE}).`,
+          metadata: { url: fetchUrl, size: body.length }
+        };
+      }
+      let textContent;
+      if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
+        textContent = htmlToText(body);
+      } else if (contentType.includes("application/json")) {
+        try {
+          const json = JSON.parse(body);
+          textContent = JSON.stringify(json, null, 2);
+        } catch {
+          textContent = body;
+        }
+      } else {
+        textContent = body;
+      }
+      if (textContent.length > MAX_OUTPUT_LENGTH) {
+        textContent = textContent.slice(0, MAX_OUTPUT_LENGTH) + "\n\n... [content truncated] ...";
+      }
+      let output = textContent;
+      if (prompt) {
+        output = `[Prompt: ${prompt}]
+
+${textContent}`;
+      }
+      return {
+        success: true,
+        output,
+        metadata: {
+          url: fetchUrl,
+          status: response.status,
+          contentType,
+          size: body.length,
+          truncated: textContent.length > MAX_OUTPUT_LENGTH
+        }
+      };
+    } catch (err) {
+      if (err.name === "AbortError") {
+        if (context.abortSignal.aborted) {
+          return {
+            success: false,
+            output: "",
+            error: "Request was aborted."
+          };
+        }
+        return {
+          success: false,
+          output: "",
+          error: `Request timed out after ${DEFAULT_TIMEOUT_MS2}ms.`,
+          metadata: { url: fetchUrl, timedOut: true }
+        };
+      }
+      return {
+        success: false,
+        output: "",
+        error: `Fetch failed: ${err.message}`,
+        metadata: { url: fetchUrl }
+      };
+    } finally {
+      clearTimeout(timeoutId);
+      context.abortSignal.removeEventListener("abort", onContextAbort);
+      this.abortController = null;
+    }
+  }
+  abort(_reason) {
+    this.abortController?.abort();
+  }
+  /**
+   * Attempt an x402 auto-payment for a 402 response.
+   *
+   * Parses the 402 body, builds an EIP-3009 authorization struct, signs it
+   * using context.x402Signer, and returns the base64-encoded X-PAYMENT header
+   * value. Returns an error string if payment is not possible.
+   */
+  async tryX402Payment(response, context) {
+    if (!context.x402Signer || !context.agentWalletAddress) {
+      return {
+        error: "No x402 signer configured. Set x402.client.privateKey to enable auto-payment."
+      };
+    }
+    let body;
+    try {
+      const text = await response.text();
+      body = JSON.parse(text);
+    } catch {
+      return { error: "Could not parse x402 payment requirements from 402 response body." };
+    }
+    const req = body.accepts?.find((r) => r.scheme === "exact") ?? body.accepts?.[0];
+    if (!req) {
+      return { error: "No acceptable payment scheme found in 402 response." };
+    }
+    const nowSecs = Math.floor(Date.now() / 1e3);
+    const authorization = {
+      from: context.agentWalletAddress,
+      to: req.payTo,
+      value: req.maxAmountRequired,
+      validAfter: "0",
+      validBefore: String(nowSecs + req.maxTimeoutSeconds),
+      nonce: "0x" + randomBytes(32).toString("hex")
+    };
+    let signature;
+    try {
+      signature = await context.x402Signer(authorization);
+    } catch (err) {
+      return { error: `x402 signing failed: ${err.message}` };
+    }
+    const payload = {
+      x402Version: 1,
+      scheme: req.scheme,
+      network: req.network,
+      payload: { signature, authorization }
+    };
+    return { headerValue: Buffer.from(JSON.stringify(payload)).toString("base64") };
+  }
+};
+function htmlToText(html) {
+  let text = html;
+  text = text.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "");
+  text = text.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "");
+  text = text.replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, "");
+  text = text.replace(/<!--[\s\S]*?-->/g, "");
+  text = text.replace(/<\/?(p|div|br|hr|h[1-6]|ul|ol|li|table|tr|td|th|blockquote|pre|section|article|header|footer|nav|main|aside|figure|figcaption)\b[^>]*\/?>/gi, "\n");
+  text = text.replace(/<[^>]+>/g, "");
+  text = decodeHtmlEntities(text);
+  text = text.replace(/[^\S\n]+/g, " ");
+  text = text.replace(/\n\s*\n/g, "\n\n");
+  text = text.replace(/\n{3,}/g, "\n\n");
+  return text.trim();
+}
+function decodeHtmlEntities(text) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+    "&mdash;": "\u2014",
+    "&ndash;": "\u2013",
+    "&laquo;": "\xAB",
+    "&raquo;": "\xBB",
+    "&bull;": "\u2022",
+    "&hellip;": "\u2026",
+    "&copy;": "\xA9",
+    "&reg;": "\xAE",
+    "&trade;": "\u2122"
+  };
+  let result = text;
+  for (const [entity, char] of Object.entries(entities)) {
+    result = result.split(entity).join(char);
+  }
+  result = result.replace(/&#(\d+);/g, (_, code) => {
+    const num = parseInt(code, 10);
+    return num > 0 && num < 1114112 ? String.fromCodePoint(num) : "";
+  });
+  result = result.replace(/&#x([0-9a-fA-F]+);/g, (_, code) => {
+    const num = parseInt(code, 16);
+    return num > 0 && num < 1114112 ? String.fromCodePoint(num) : "";
+  });
+  return result;
+}
+var BRAVE_API_URL = "https://api.search.brave.com/res/v1/web/search";
+var DEFAULT_TIMEOUT_MS3 = 15e3;
+var MAX_OUTPUT_LENGTH2 = 5e4;
+var VALID_FRESHNESS = /* @__PURE__ */ new Set(["pd", "pw", "pm", "py"]);
+var WebSearchTool = class {
+  name = "web_search";
+  description = "Search the web for current information. Returns titles, URLs, and descriptions from web search results. Use this to find facts, research topics, or look up current events.";
+  // Lightweight: web_search is a single HTTP call to the Brave API.  It does
+  // not need worker-pool process isolation, and running inline ensures the
+  // full ToolContext (searchApiKey, searchConfig) is available — the worker
+  // context is stripped to sessionId+cwd and would lose the API key.
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "The search query. Be specific for better results.",
+        minLength: 1
+      },
+      count: {
+        type: "integer",
+        description: "Number of results to return (1-20). Default: 5.",
+        minimum: 1,
+        maximum: 20
+      },
+      offset: {
+        type: "integer",
+        description: "Pagination offset. Use to get additional pages of results.",
+        minimum: 0
+      },
+      freshness: {
+        type: "string",
+        description: "Time filter for results. pd=past day, pw=past week, pm=past month, py=past year.",
+        enum: ["pd", "pw", "pm", "py"]
+      },
+      country: {
+        type: "string",
+        description: "Country code for localized results (e.g., US, GB, DE)."
+      }
+    },
+    required: ["query"],
+    additionalProperties: false
+  };
+  abortController = null;
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { query, count, offset, freshness, country } = args;
+    const errors = [];
+    if (typeof query !== "string" || query.trim().length === 0) {
+      errors.push("query must be a non-empty string.");
+    } else if (query.length > 2e3) {
+      errors.push("query must be 2000 characters or fewer.");
+    }
+    if (count !== void 0) {
+      if (typeof count !== "number" || !Number.isInteger(count) || count < 1 || count > 20) {
+        errors.push("count must be an integer between 1 and 20.");
+      }
+    }
+    if (offset !== void 0) {
+      if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
+        errors.push("offset must be a non-negative integer.");
+      }
+    }
+    if (freshness !== void 0) {
+      if (typeof freshness !== "string" || !VALID_FRESHNESS.has(freshness)) {
+        errors.push("freshness must be one of: pd, pw, pm, py.");
+      }
+    }
+    if (country !== void 0) {
+      if (typeof country !== "string" || country.trim().length === 0) {
+        errors.push("country must be a non-empty string.");
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const { query, count, offset, freshness, country } = args;
+    const searchContext = context;
+    const apiKey = searchContext.searchApiKey || process.env.BRAVE_SEARCH_API_KEY;
+    if (!apiKey) {
+      return {
+        success: false,
+        output: "",
+        error: "Web search is not available: no Brave Search API key found. The BRAVE_SEARCH_API_KEY environment variable is not set, and search.apiKey is not configured in ~/.ch4p/config.json. Please tell the user to set the BRAVE_SEARCH_API_KEY environment variable in the shell where the ch4p gateway is running."
+      };
+    }
+    if (context.abortSignal.aborted) {
+      return {
+        success: false,
+        output: "",
+        error: "Request aborted before execution."
+      };
+    }
+    this.abortController = new AbortController();
+    const onContextAbort = () => this.abortController?.abort();
+    context.abortSignal.addEventListener("abort", onContextAbort, { once: true });
+    const timeoutId = setTimeout(() => {
+      this.abortController?.abort();
+    }, DEFAULT_TIMEOUT_MS3);
+    try {
+      context.onProgress(`Searching for "${query}"...`);
+      const searchConfig = searchContext.searchConfig ?? {};
+      const effectiveCount = count ?? searchConfig.maxResults ?? 5;
+      const url = new URL(BRAVE_API_URL);
+      url.searchParams.set("q", query);
+      url.searchParams.set("count", String(effectiveCount));
+      if (offset) url.searchParams.set("offset", String(offset));
+      if (freshness) url.searchParams.set("freshness", freshness);
+      const effectiveCountry = country ?? searchConfig.country;
+      if (effectiveCountry) url.searchParams.set("country", effectiveCountry);
+      if (searchConfig.searchLang) {
+        url.searchParams.set("search_lang", searchConfig.searchLang);
+      }
+      const response = await fetch(url.toString(), {
+        signal: this.abortController.signal,
+        headers: {
+          "Accept": "application/json",
+          "Accept-Encoding": "gzip",
+          "X-Subscription-Token": apiKey
+        }
+      });
+      if (!response.ok) {
+        const status = response.status;
+        if (status === 401 || status === 403) {
+          return {
+            success: false,
+            output: "",
+            error: "Invalid or expired Brave Search API key.",
+            metadata: { query, status }
+          };
+        }
+        if (status === 429) {
+          return {
+            success: false,
+            output: "",
+            error: "Brave Search rate limit exceeded. Try again later.",
+            metadata: { query, status }
+          };
+        }
+        return {
+          success: false,
+          output: "",
+          error: `Search API returned HTTP ${status}: ${response.statusText}`,
+          metadata: { query, status }
+        };
+      }
+      const data = await response.json();
+      const results = data.web?.results ?? [];
+      let output = formatSearchResults(results, data.query);
+      if (output.length > MAX_OUTPUT_LENGTH2) {
+        output = output.slice(0, MAX_OUTPUT_LENGTH2) + "\n\n... [results truncated] ...";
+      }
+      return {
+        success: true,
+        output,
+        metadata: {
+          query,
+          provider: "brave",
+          resultCount: results.length,
+          offset: offset ?? 0
+        }
+      };
+    } catch (err) {
+      if (err.name === "AbortError") {
+        if (context.abortSignal.aborted) {
+          return {
+            success: false,
+            output: "",
+            error: "Request was aborted."
+          };
+        }
+        return {
+          success: false,
+          output: "",
+          error: `Search request timed out after ${DEFAULT_TIMEOUT_MS3}ms.`,
+          metadata: { query, timedOut: true }
+        };
+      }
+      return {
+        success: false,
+        output: "",
+        error: `Search failed: ${err.message}`,
+        metadata: { query }
+      };
+    } finally {
+      clearTimeout(timeoutId);
+      context.abortSignal.removeEventListener("abort", onContextAbort);
+      this.abortController = null;
+    }
+  }
+  abort(_reason) {
+    this.abortController?.abort();
+  }
+};
+function formatSearchResults(results, queryInfo) {
+  if (results.length === 0) {
+    return "No search results found.";
+  }
+  const lines = [];
+  if (queryInfo?.altered && queryInfo.altered !== queryInfo.original) {
+    lines.push(`Showing results for: "${queryInfo.altered}" (original: "${queryInfo.original}")
+`);
+  }
+  lines.push(`Found ${results.length} result${results.length === 1 ? "" : "s"}:
+`);
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    lines.push(`[${i + 1}] ${r.title}`);
+    lines.push(`    URL: ${r.url}`);
+    if (r.description) {
+      lines.push(`    ${r.description}`);
+    }
+    if (r.age) {
+      lines.push(`    Age: ${r.age}`);
+    }
+    if (r.extra_snippets && r.extra_snippets.length > 0) {
+      lines.push(`    Snippets: ${r.extra_snippets.join(" | ")}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var MemoryStoreTool = class {
+  name = "memory_store";
+  description = "Store content in persistent memory for later retrieval. Each entry has a unique key, content string, and optional metadata. Stored entries can be recalled using semantic or keyword search.";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      key: {
+        type: "string",
+        description: 'Unique key for the memory entry. Use descriptive keys like "project/architecture" or "user/preferences".',
+        minLength: 1,
+        maxLength: 256
+      },
+      content: {
+        type: "string",
+        description: "The content to store.",
+        minLength: 1
+      },
+      metadata: {
+        type: "object",
+        description: "Optional metadata to associate with the entry (e.g. tags, source, timestamp).",
+        additionalProperties: true
+      }
+    },
+    required: ["key", "content"],
+    additionalProperties: false
+  };
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { key, content, metadata } = args;
+    const errors = [];
+    if (typeof key !== "string" || key.trim().length === 0) {
+      errors.push("key must be a non-empty string.");
+    }
+    if (typeof key === "string" && key.length > 256) {
+      errors.push("key must not exceed 256 characters.");
+    }
+    if (typeof content !== "string" || content.length === 0) {
+      errors.push("content must be a non-empty string.");
+    }
+    if (metadata !== void 0) {
+      if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        errors.push("metadata must be a plain object.");
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const memoryContext = context;
+    if (!memoryContext.memoryBackend) {
+      throw new ToolError(
+        "Memory backend is not available. Configure a memory backend to use memory tools.",
+        this.name
+      );
+    }
+    const { key, content, metadata } = args;
+    try {
+      await memoryContext.memoryBackend.store(key, content, metadata);
+    } catch (err) {
+      return {
+        success: false,
+        output: "",
+        error: `Failed to store memory entry: ${err.message}`
+      };
+    }
+    return {
+      success: true,
+      output: `Stored memory entry with key "${key}" (${content.length} chars).`,
+      metadata: {
+        key,
+        contentLength: content.length,
+        hasMetadata: metadata !== void 0
+      }
+    };
+  }
+};
+var DEFAULT_LIMIT = 10;
+var MAX_LIMIT = 50;
+var MemoryRecallTool = class {
+  name = "memory_recall";
+  description = "Query persistent memory using hybrid search (semantic + keyword). Returns ranked results matching the query. Use this to recall previously stored information, context, or decisions.";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "The search query. Can be natural language or keywords.",
+        minLength: 1
+      },
+      limit: {
+        type: "number",
+        description: `Maximum number of results to return. Defaults to ${DEFAULT_LIMIT}, max ${MAX_LIMIT}.`,
+        minimum: 1,
+        maximum: MAX_LIMIT
+      }
+    },
+    required: ["query"],
+    additionalProperties: false
+  };
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { query, limit } = args;
+    const errors = [];
+    if (typeof query !== "string" || query.trim().length === 0) {
+      errors.push("query must be a non-empty string.");
+    }
+    if (limit !== void 0) {
+      if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1) {
+        errors.push("limit must be a positive integer.");
+      }
+      if (typeof limit === "number" && limit > MAX_LIMIT) {
+        errors.push(`limit cannot exceed ${MAX_LIMIT}.`);
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const memoryContext = context;
+    if (!memoryContext.memoryBackend) {
+      throw new ToolError(
+        "Memory backend is not available. Configure a memory backend to use memory tools.",
+        this.name
+      );
+    }
+    const { query, limit } = args;
+    const resultLimit = Math.min(limit ?? DEFAULT_LIMIT, MAX_LIMIT);
+    try {
+      const results = await memoryContext.memoryBackend.recall(query, {
+        limit: resultLimit
+      });
+      if (results.length === 0) {
+        return {
+          success: true,
+          output: "No matching memory entries found.",
+          metadata: { query, resultCount: 0 }
+        };
+      }
+      const formatted = results.map((r, i) => {
+        const header = `[${i + 1}] ${r.key} (score: ${r.score.toFixed(3)}, match: ${r.matchType})`;
+        const metaStr = r.metadata ? `
+    metadata: ${JSON.stringify(r.metadata)}` : "";
+        return `${header}${metaStr}
+${r.content}`;
+      });
+      return {
+        success: true,
+        output: formatted.join("\n\n---\n\n"),
+        metadata: {
+          query,
+          resultCount: results.length,
+          topScore: results[0]?.score
+        }
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: "",
+        error: `Memory recall failed: ${err.message}`
+      };
+    }
+  }
+};
+var DelegateTool = class {
+  name = "delegate";
+  description = "Delegate a task to a sub-agent, optionally on a different execution engine or model. Useful for parallelizing work or leveraging specialized models for specific subtasks.";
+  weight = "heavyweight";
+  parameters = {
+    type: "object",
+    properties: {
+      task: {
+        type: "string",
+        description: "The task description for the sub-agent to execute.",
+        minLength: 1
+      },
+      engine: {
+        type: "string",
+        description: "Engine ID to run the sub-agent on. Defaults to the current engine."
+      },
+      model: {
+        type: "string",
+        description: "Model ID to use for the sub-agent. Defaults to the current model."
+      },
+      context: {
+        type: "string",
+        description: "Optional parent context snippet to pass to the sub-agent (e.g. a conversation summary or relevant background). The sub-agent sees this as prior context before the task."
+      }
+    },
+    required: ["task"],
+    additionalProperties: false
+  };
+  cancelFn = null;
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { task, engine, model } = args;
+    const errors = [];
+    if (typeof task !== "string" || task.trim().length === 0) {
+      errors.push("task must be a non-empty string.");
+    }
+    if (engine !== void 0 && typeof engine !== "string") {
+      errors.push("engine must be a string.");
+    }
+    if (model !== void 0 && typeof model !== "string") {
+      errors.push("model must be a string.");
+    }
+    const { context } = args;
+    if (context !== void 0 && typeof context !== "string") {
+      errors.push("context must be a string.");
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const delegateContext = context;
+    if (!delegateContext.resolveEngine) {
+      throw new ToolError(
+        "Engine resolution is not available. The delegate tool requires access to the engine registry.",
+        this.name
+      );
+    }
+    const { task, engine: engineId, model, context: parentContext } = args;
+    const targetEngine = delegateContext.resolveEngine(engineId);
+    if (!targetEngine) {
+      return {
+        success: false,
+        output: "",
+        error: engineId ? `Engine "${engineId}" not found.` : "No default engine available."
+      };
+    }
+    if (context.abortSignal.aborted) {
+      return {
+        success: false,
+        output: "",
+        error: "Delegation aborted before execution."
+      };
+    }
+    context.onProgress(
+      `Delegating to ${targetEngine.name}${model ? ` (model: ${model})` : ""}...`
+    );
+    try {
+      const taskContent = parentContext ? `[Context]
+${parentContext}
+
+[Task]
+${task}` : task;
+      const subMessages = [
+        { role: "user", content: taskContent }
+      ];
+      const handle = await targetEngine.startRun(
+        {
+          sessionId: `${context.sessionId}-delegate-${Date.now()}`,
+          messages: subMessages,
+          model: model ?? delegateContext.defaultModel,
+          systemPrompt: "You are a sub-agent executing a delegated task. Complete the task thoroughly and return your findings."
+        },
+        {
+          signal: context.abortSignal,
+          onProgress: (event) => {
+            if (event.type === "text_delta") {
+              context.onProgress(event.delta);
+            }
+          }
+        }
+      );
+      this.cancelFn = () => handle.cancel();
+      let answer = "";
+      let usage;
+      for await (const event of handle.events) {
+        if (context.abortSignal.aborted) {
+          await handle.cancel();
+          return {
+            success: false,
+            output: answer,
+            error: "Delegation was aborted."
+          };
+        }
+        switch (event.type) {
+          case "text_delta":
+            answer += event.delta;
+            break;
+          case "completed":
+            answer = event.answer;
+            usage = event.usage;
+            break;
+          case "error":
+            return {
+              success: false,
+              output: answer,
+              error: `Sub-agent error: ${event.error.message}`
+            };
+        }
+      }
+      this.cancelFn = null;
+      return {
+        success: true,
+        output: answer,
+        metadata: {
+          engine: targetEngine.id,
+          model: model ?? delegateContext.defaultModel,
+          usage
+        }
+      };
+    } catch (err) {
+      this.cancelFn = null;
+      if (err.name === "AbortError") {
+        return {
+          success: false,
+          output: "",
+          error: "Delegation was aborted."
+        };
+      }
+      return {
+        success: false,
+        output: "",
+        error: `Delegation failed: ${err.message}`
+      };
+    }
+  }
+  abort(_reason) {
+    this.cancelFn?.();
+    this.cancelFn = null;
+  }
+};
+var Semaphore = class {
+  count;
+  queue = [];
+  constructor(limit) {
+    this.count = limit;
+  }
+  async acquire() {
+    if (this.count > 0) {
+      this.count--;
+      return;
+    }
+    return new Promise((resolve7) => {
+      this.queue.push(resolve7);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.count++;
+    }
+  }
+};
+var MeshTool = class {
+  name = "mesh";
+  description = "Execute multiple tasks in parallel across sub-agents. Each task can target a different engine or model. Results are collected and returned as a structured aggregate. Use this for parallelizable work like research, analysis, or multi-perspective problem solving.";
+  weight = "heavyweight";
+  parameters = {
+    type: "object",
+    properties: {
+      tasks: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            task: {
+              type: "string",
+              description: "Task description for the sub-agent.",
+              minLength: 1
+            },
+            engine: {
+              type: "string",
+              description: "Engine ID to run this task on (optional, defaults to current)."
+            },
+            model: {
+              type: "string",
+              description: "Model ID for this task (optional)."
+            },
+            context: {
+              type: "string",
+              description: "Optional parent context snippet to pass to this sub-agent task (e.g. a conversation summary or relevant background)."
+            }
+          },
+          required: ["task"],
+          additionalProperties: false
+        },
+        description: "Array of tasks to execute in parallel across sub-agents (at least 1)."
+      },
+      concurrency: {
+        type: "number",
+        description: "Max parallel sub-agents (default: from config or 3).",
+        minimum: 1,
+        maximum: 10
+      }
+    },
+    required: ["tasks"],
+    additionalProperties: false
+  };
+  cancelFns = [];
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { tasks, concurrency } = args;
+    const errors = [];
+    if (!Array.isArray(tasks) || tasks.length === 0) {
+      errors.push("tasks must be a non-empty array.");
+    } else {
+      for (let i = 0; i < tasks.length; i++) {
+        const t = tasks[i];
+        if (!t || typeof t.task !== "string" || t.task.trim().length === 0) {
+          errors.push(`tasks[${i}].task must be a non-empty string.`);
+        }
+        if (t?.engine !== void 0 && typeof t.engine !== "string") {
+          errors.push(`tasks[${i}].engine must be a string.`);
+        }
+        if (t?.model !== void 0 && typeof t.model !== "string") {
+          errors.push(`tasks[${i}].model must be a string.`);
+        }
+      }
+    }
+    if (concurrency !== void 0) {
+      if (typeof concurrency !== "number" || concurrency < 1 || concurrency > 10) {
+        errors.push("concurrency must be a number between 1 and 10.");
+      }
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const meshContext = context;
+    if (!meshContext.resolveEngine) {
+      throw new ToolError(
+        "Engine resolution is not available. The mesh tool requires access to the engine registry.",
+        this.name
+      );
+    }
+    const { tasks, concurrency: requestedConcurrency } = args;
+    const maxConcurrency = requestedConcurrency ?? meshContext.meshConfig?.maxConcurrency ?? 3;
+    const defaultTimeout = meshContext.meshConfig?.defaultTimeout ?? 12e4;
+    if (context.abortSignal.aborted) {
+      return {
+        success: false,
+        output: "",
+        error: "Mesh execution aborted before start."
+      };
+    }
+    context.onProgress(
+      `Spawning ${tasks.length} sub-agent(s) with concurrency ${maxConcurrency}...`
+    );
+    const semaphore = new Semaphore(maxConcurrency);
+    this.cancelFns = [];
+    const outcomes = await Promise.allSettled(
+      tasks.map(
+        (task, index) => this.executeTask(task, index, meshContext, semaphore, defaultTimeout)
+      )
+    );
+    const results = outcomes.map((outcome, index) => {
+      if (outcome.status === "fulfilled") {
+        return outcome.value;
+      }
+      return {
+        task: tasks[index].task,
+        engine: tasks[index].engine ?? "default",
+        success: false,
+        output: "",
+        error: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason),
+        durationMs: 0
+      };
+    });
+    this.cancelFns = [];
+    const succeeded = results.filter((r) => r.success).length;
+    const failed = results.length - succeeded;
+    const outputLines = results.map((r, i) => {
+      const status = r.success ? "\u2713" : "\u2717";
+      const header = `[${status}] Task ${i + 1}: ${r.task.slice(0, 80)}`;
+      const engineInfo = `    Engine: ${r.engine} (${r.durationMs}ms)`;
+      const body = r.success ? r.output.split("\n").map((l) => `    ${l}`).join("\n") : `    Error: ${r.error}`;
+      return `${header}
+${engineInfo}
+${body}`;
+    });
+    const summary = `${succeeded}/${results.length} tasks succeeded` + (failed > 0 ? ` (${failed} failed)` : "");
+    return {
+      success: failed === 0,
+      output: `${summary}
+
+${outputLines.join("\n\n")}`,
+      metadata: {
+        total: results.length,
+        succeeded,
+        failed,
+        results: results.map((r) => ({
+          task: r.task,
+          engine: r.engine,
+          success: r.success,
+          durationMs: r.durationMs,
+          error: r.error
+        }))
+      }
+    };
+  }
+  abort(_reason) {
+    for (const cancel of this.cancelFns) {
+      cancel().catch(() => {
+      });
+    }
+    this.cancelFns = [];
+  }
+  // -------------------------------------------------------------------------
+  // Private
+  // -------------------------------------------------------------------------
+  async executeTask(task, _index, context, semaphore, timeout) {
+    await semaphore.acquire();
+    const startTime = Date.now();
+    try {
+      if (context.abortSignal.aborted) {
+        return {
+          task: task.task,
+          engine: task.engine ?? "default",
+          success: false,
+          output: "",
+          error: "Aborted.",
+          durationMs: 0
+        };
+      }
+      const targetEngine = context.resolveEngine(task.engine);
+      if (!targetEngine) {
+        return {
+          task: task.task,
+          engine: task.engine ?? "default",
+          success: false,
+          output: "",
+          error: task.engine ? `Engine "${task.engine}" not found.` : "No default engine available.",
+          durationMs: Date.now() - startTime
+        };
+      }
+      const taskAbort = new AbortController();
+      const timeoutId = setTimeout(() => taskAbort.abort(), timeout);
+      const parentAbortHandler = () => taskAbort.abort();
+      context.abortSignal.addEventListener("abort", parentAbortHandler, { once: true });
+      try {
+        const taskContent = task.context ? `[Context]
+${task.context}
+
+[Task]
+${task.task}` : task.task;
+        const subMessages = [
+          { role: "user", content: taskContent }
+        ];
+        const handle = await targetEngine.startRun(
+          {
+            sessionId: `${context.sessionId}-mesh-${Date.now()}-${_index}`,
+            messages: subMessages,
+            model: task.model ?? context.defaultModel,
+            systemPrompt: "You are a sub-agent executing a delegated task as part of a parallel mesh. Complete the task thoroughly and return your findings concisely."
+          },
+          {
+            signal: taskAbort.signal,
+            onProgress: (event) => {
+              if (event.type === "text_delta") {
+                context.onProgress(`[Task ${_index + 1}] ${event.delta}`);
+              }
+            }
+          }
+        );
+        this.cancelFns.push(() => handle.cancel());
+        let answer = "";
+        for await (const event of handle.events) {
+          if (taskAbort.signal.aborted) {
+            await handle.cancel();
+            return {
+              task: task.task,
+              engine: targetEngine.id,
+              success: false,
+              output: answer,
+              error: "Task timed out or was aborted.",
+              durationMs: Date.now() - startTime
+            };
+          }
+          switch (event.type) {
+            case "text_delta":
+              answer += event.delta;
+              break;
+            case "completed":
+              answer = event.answer;
+              break;
+            case "error":
+              return {
+                task: task.task,
+                engine: targetEngine.id,
+                success: false,
+                output: answer,
+                error: `Sub-agent error: ${event.error.message}`,
+                durationMs: Date.now() - startTime
+              };
+          }
+        }
+        return {
+          task: task.task,
+          engine: targetEngine.id,
+          success: true,
+          output: answer,
+          durationMs: Date.now() - startTime
+        };
+      } finally {
+        clearTimeout(timeoutId);
+        context.abortSignal.removeEventListener("abort", parentAbortHandler);
+      }
+    } catch (err) {
+      return {
+        task: task.task,
+        engine: task.engine ?? "default",
+        success: false,
+        output: "",
+        error: err.name === "AbortError" ? "Task timed out or was aborted." : `Task failed: ${err.message}`,
+        durationMs: Date.now() - startTime
+      };
+    } finally {
+      semaphore.release();
+    }
+  }
+};
+var NAV_TIMEOUT_MS = 3e4;
+var MAX_SCREENSHOT_SIZE = 5 * 1024 * 1024;
+var MAX_EVAL_OUTPUT = 5e4;
+var MAX_WAIT_MS = 1e4;
+var MAX_TEXT_EXCERPT = 2e3;
+var VALID_ACTIONS = /* @__PURE__ */ new Set([
+  "navigate",
+  "click",
+  "type",
+  "screenshot",
+  "evaluate",
+  "scroll",
+  "wait",
+  "close"
+]);
+var VALID_DIRECTIONS = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+var BrowserTool = class {
+  name = "browser";
+  description = "Control a headless browser. Navigate to URLs, click elements, type text, take screenshots, evaluate JavaScript, and scroll pages. The browser persists across calls within a session.";
+  weight = "heavyweight";
+  parameters = {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        description: "The browser action to perform: navigate, click, type, screenshot, evaluate, scroll, wait, or close.",
+        enum: ["navigate", "click", "type", "screenshot", "evaluate", "scroll", "wait", "close"]
+      },
+      url: {
+        type: "string",
+        description: "URL to navigate to (required for navigate action)."
+      },
+      selector: {
+        type: "string",
+        description: "CSS selector of the target element (required for click and type actions)."
+      },
+      text: {
+        type: "string",
+        description: "Text to type into the selected element (required for type action)."
+      },
+      expression: {
+        type: "string",
+        description: "JavaScript expression to evaluate in the page context (required for evaluate action)."
+      },
+      direction: {
+        type: "string",
+        description: "Scroll direction: up, down, left, or right. Default: down.",
+        enum: ["up", "down", "left", "right"]
+      },
+      distance: {
+        type: "number",
+        description: "Scroll distance in pixels. Default: 500.",
+        minimum: 1,
+        maximum: 1e4
+      },
+      timeout: {
+        type: "number",
+        description: "Wait time in milliseconds (for wait action). Max 10000.",
+        minimum: 100,
+        maximum: 1e4
+      },
+      fullPage: {
+        type: "boolean",
+        description: "Whether to capture a full-page screenshot. Default: false."
+      }
+    },
+    required: ["action"],
+    additionalProperties: false
+  };
+  // Persistent browser state.
+  browser = null;
+  page = null;
+  launching = false;
+  // ---------------------------------------------------------------------------
+  // Validation
+  // ---------------------------------------------------------------------------
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const a = args;
+    const errors = [];
+    if (typeof a.action !== "string" || !VALID_ACTIONS.has(a.action)) {
+      errors.push(`action must be one of: ${[...VALID_ACTIONS].join(", ")}.`);
+      return { valid: false, errors };
+    }
+    const action = a.action;
+    switch (action) {
+      case "navigate":
+        if (typeof a.url !== "string" || a.url.trim().length === 0) {
+          errors.push("url is required for navigate action.");
+        } else {
+          try {
+            const parsed = new URL(a.url);
+            if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+              errors.push("url must use http or https protocol.");
+            }
+            if (isBlockedHostname(parsed.hostname)) {
+              errors.push("url targets a blocked or private network address.");
+            }
+          } catch {
+            errors.push("url must be a valid URL.");
+          }
+        }
+        break;
+      case "click":
+        if (typeof a.selector !== "string" || a.selector.trim().length === 0) {
+          errors.push("selector is required for click action.");
+        }
+        break;
+      case "type":
+        if (typeof a.selector !== "string" || a.selector.trim().length === 0) {
+          errors.push("selector is required for type action.");
+        }
+        if (typeof a.text !== "string") {
+          errors.push("text is required for type action.");
+        }
+        break;
+      case "evaluate":
+        if (typeof a.expression !== "string" || a.expression.trim().length === 0) {
+          errors.push("expression is required for evaluate action.");
+        }
+        break;
+      case "scroll":
+        if (a.direction !== void 0 && (typeof a.direction !== "string" || !VALID_DIRECTIONS.has(a.direction))) {
+          errors.push("direction must be one of: up, down, left, right.");
+        }
+        if (a.distance !== void 0) {
+          if (typeof a.distance !== "number" || a.distance < 1 || a.distance > 1e4) {
+            errors.push("distance must be a number between 1 and 10000.");
+          }
+        }
+        break;
+      case "wait":
+        if (a.timeout !== void 0) {
+          if (typeof a.timeout !== "number" || a.timeout < 100 || a.timeout > MAX_WAIT_MS) {
+            errors.push(`timeout must be between 100 and ${MAX_WAIT_MS}ms.`);
+          }
+        }
+        break;
+      case "screenshot":
+        if (a.fullPage !== void 0 && typeof a.fullPage !== "boolean") {
+          errors.push("fullPage must be a boolean.");
+        }
+        break;
+      case "close":
+        break;
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  // ---------------------------------------------------------------------------
+  // Execute
+  // ---------------------------------------------------------------------------
+  async execute(args, context) {
+    const validation = this.validate(args);
+    if (!validation.valid) {
+      return {
+        success: false,
+        output: "",
+        error: `Invalid arguments: ${validation.errors.join(" ")}`
+      };
+    }
+    const a = args;
+    if (context.abortSignal.aborted) {
+      return { success: false, output: "", error: "Request aborted before execution." };
+    }
+    if (a.action === "evaluate" && context.securityPolicy) {
+      const policy = context.securityPolicy;
+      const autonomy = policy.autonomyLevel;
+      if (autonomy === "readonly") {
+        return {
+          success: false,
+          output: "",
+          error: "evaluate action is blocked in readonly autonomy mode."
+        };
+      }
+    }
+    if (a.action === "close") {
+      return this.doClose();
+    }
+    const ensureResult = await this.ensureBrowser(context);
+    if (ensureResult) return ensureResult;
+    try {
+      switch (a.action) {
+        case "navigate":
+          return await this.doNavigate(a, context);
+        case "click":
+          return await this.doClick(a);
+        case "type":
+          return await this.doType(a);
+        case "screenshot":
+          return await this.doScreenshot(a);
+        case "evaluate":
+          return await this.doEvaluate(a);
+        case "scroll":
+          return await this.doScroll(a);
+        case "wait":
+          return await this.doWait(a);
+        default:
+          return { success: false, output: "", error: `Unknown action: ${a.action}` };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { success: false, output: "", error: `Browser error: ${message}` };
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // AWM state snapshot
+  // ---------------------------------------------------------------------------
+  async getStateSnapshot(_args, _context) {
+    const state = {};
+    if (this.page && !this.page.isClosed()) {
+      try {
+        state.url = this.page.url();
+        state.title = await this.page.title();
+        const excerpt = await this.page.evaluate(
+          '(() => { const b = document.body; return b ? (b.innerText || "").slice(0, 2000) : ""; })()'
+        ).catch(() => "");
+        state.visibleText = (excerpt ?? "").slice(0, MAX_TEXT_EXCERPT);
+      } catch {
+        state.url = "unknown";
+        state.title = "unknown";
+      }
+    } else {
+      state.url = null;
+      state.title = null;
+      state.browserRunning = false;
+    }
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      state,
+      description: state.url ? `Browser at ${state.url} \u2014 "${state.title}"` : "Browser not running"
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Abort
+  // ---------------------------------------------------------------------------
+  abort(_reason) {
+    this.closeBrowser().catch(() => {
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Browser lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Ensure the browser is launched. Lazy-starts on first call.
+   * Returns a ToolResult error if playwright-core is not available.
+   */
+  async ensureBrowser(context) {
+    if (this.page && !this.page.isClosed()) return null;
+    if (this.browser && this.browser.isConnected()) {
+      this.page = await this.browser.newPage();
+      return null;
+    }
+    if (this.launching) {
+      return { success: false, output: "", error: "Browser is already launching." };
+    }
+    this.launching = true;
+    try {
+      const pw = await import("playwright-core").catch(() => null);
+      if (!pw) {
+        return {
+          success: false,
+          output: "",
+          error: "playwright-core is not installed. Run: npm install -D playwright-core && npx playwright install chromium"
+        };
+      }
+      let executablePath;
+      for (const browserType of [pw.chromium, pw.firefox, pw.webkit]) {
+        try {
+          executablePath = browserType.executablePath();
+          if (executablePath) {
+            this.browser = await browserType.launch({
+              headless: true,
+              args: ["--disable-dev-shm-usage", "--no-sandbox"]
+            });
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (!this.browser) {
+        return {
+          success: false,
+          output: "",
+          error: "No browser found. Install one with: npx playwright install chromium"
+        };
+      }
+      this.page = await this.browser.newPage();
+      context.abortSignal.addEventListener("abort", () => {
+        this.closeBrowser().catch(() => {
+        });
+      }, { once: true });
+      return null;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        output: "",
+        error: `Failed to launch browser: ${message}`
+      };
+    } finally {
+      this.launching = false;
+    }
+  }
+  async closeBrowser() {
+    if (this.page && !this.page.isClosed()) {
+      try {
+        await this.page.close();
+      } catch {
+      }
+    }
+    this.page = null;
+    if (this.browser) {
+      try {
+        await this.browser.close();
+      } catch {
+      }
+    }
+    this.browser = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Action implementations
+  // ---------------------------------------------------------------------------
+  async doNavigate(a, context) {
+    let url = a.url;
+    url = url.replace(/^http:\/\//, "https://");
+    try {
+      const parsed = new URL(url);
+      const dnsCheck = await resolveAndCheckPrivate(parsed.hostname);
+      if (dnsCheck.blocked) {
+        return {
+          success: false,
+          output: "",
+          error: `SSRF blocked: ${dnsCheck.reason}`,
+          metadata: { url, ssrfBlocked: true }
+        };
+      }
+    } catch {
+      return {
+        success: false,
+        output: "",
+        error: "Failed to parse URL for SSRF check.",
+        metadata: { url }
+      };
+    }
+    context.onProgress(`Navigating to ${url}...`);
+    await this.page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: NAV_TIMEOUT_MS
+    });
+    const title = await this.page.title();
+    const currentUrl = this.page.url();
+    return {
+      success: true,
+      output: `Navigated to ${currentUrl}
+Title: ${title}`,
+      metadata: { url: currentUrl, title }
+    };
+  }
+  async doClick(a) {
+    const selector = a.selector;
+    await this.page.click(selector, { timeout: 5e3 });
+    await this.page.waitForTimeout(500);
+    const url = this.page.url();
+    const title = await this.page.title();
+    return {
+      success: true,
+      output: `Clicked "${selector}"
+Current URL: ${url}
+Title: ${title}`,
+      metadata: { selector, url, title }
+    };
+  }
+  async doType(a) {
+    const selector = a.selector;
+    const text = a.text;
+    await this.page.fill(selector, text, { timeout: 5e3 });
+    return {
+      success: true,
+      output: `Typed ${text.length} characters into "${selector}"`,
+      metadata: { selector, length: text.length }
+    };
+  }
+  async doScreenshot(a) {
+    const fullPage = a.fullPage ?? false;
+    const buffer = await this.page.screenshot({
+      type: "png",
+      fullPage
+    });
+    if (buffer.byteLength > MAX_SCREENSHOT_SIZE) {
+      return {
+        success: false,
+        output: "",
+        error: `Screenshot too large: ${buffer.byteLength} bytes (limit: ${MAX_SCREENSHOT_SIZE}).`,
+        metadata: { size: buffer.byteLength }
+      };
+    }
+    const base64 = buffer.toString("base64");
+    const url = this.page.url();
+    const title = await this.page.title();
+    return {
+      success: true,
+      output: `Screenshot captured (${buffer.byteLength} bytes, ${fullPage ? "full page" : "viewport"})
+URL: ${url}
+Title: ${title}`,
+      metadata: {
+        url,
+        title,
+        size: buffer.byteLength,
+        fullPage,
+        base64,
+        mimeType: "image/png"
+      }
+    };
+  }
+  async doEvaluate(a) {
+    const expression = a.expression;
+    const result = await this.page.evaluate(expression);
+    let output;
+    if (result === void 0) {
+      output = "undefined";
+    } else if (result === null) {
+      output = "null";
+    } else if (typeof result === "string") {
+      output = result;
+    } else {
+      try {
+        output = JSON.stringify(result, null, 2);
+      } catch {
+        output = String(result);
+      }
+    }
+    if (output.length > MAX_EVAL_OUTPUT) {
+      output = output.slice(0, MAX_EVAL_OUTPUT) + "\n\n... [output truncated] ...";
+    }
+    return {
+      success: true,
+      output,
+      metadata: { expression, outputLength: output.length }
+    };
+  }
+  async doScroll(a) {
+    const direction = a.direction ?? "down";
+    const distance = a.distance ?? 500;
+    let deltaX = 0;
+    let deltaY = 0;
+    switch (direction) {
+      case "down":
+        deltaY = distance;
+        break;
+      case "up":
+        deltaY = -distance;
+        break;
+      case "right":
+        deltaX = distance;
+        break;
+      case "left":
+        deltaX = -distance;
+        break;
+    }
+    await this.page.evaluate(
+      `window.scrollBy(${deltaX}, ${deltaY})`
+    );
+    await this.page.waitForTimeout(300);
+    const scrollPos = await this.page.evaluate(
+      "({ x: window.scrollX, y: window.scrollY, height: document.documentElement.scrollHeight, viewportHeight: window.innerHeight })"
+    );
+    return {
+      success: true,
+      output: `Scrolled ${direction} ${distance}px
+Scroll position: ${scrollPos.y}px / ${scrollPos.height}px (viewport: ${scrollPos.viewportHeight}px)`,
+      metadata: { direction, distance, ...scrollPos }
+    };
+  }
+  async doWait(a) {
+    const timeout = a.timeout ?? 1e3;
+    const clamped = Math.min(timeout, MAX_WAIT_MS);
+    await this.page.waitForTimeout(clamped);
+    return {
+      success: true,
+      output: `Waited ${clamped}ms`,
+      metadata: { waited: clamped }
+    };
+  }
+  async doClose() {
+    const wasRunning = this.browser !== null;
+    await this.closeBrowser();
+    return {
+      success: true,
+      output: wasRunning ? "Browser closed." : "Browser was not running.",
+      metadata: { wasRunning }
+    };
+  }
+};
+var LoadSkillTool = class {
+  name = "load_skill";
+  description = "Load a skill by name to receive detailed instructions. Use this when you need the full instructions for a skill listed in your system prompt. The skill body will be returned as markdown instructions to follow.";
+  weight = "lightweight";
+  parameters = {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: 'The skill name to load (kebab-case, e.g., "code-review", "test-runner").',
+        minLength: 1,
+        maxLength: 64
+      }
+    },
+    required: ["name"],
+    additionalProperties: false
+  };
+  provider;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  validate(args) {
+    if (typeof args !== "object" || args === null) {
+      return { valid: false, errors: ["Arguments must be an object."] };
+    }
+    const { name } = args;
+    const errors = [];
+    if (typeof name !== "string" || name.trim().length === 0) {
+      errors.push("`name` is required and must be a non-empty string.");
+    }
+    return errors.length > 0 ? { valid: false, errors } : { valid: true };
+  }
+  async execute(args, _context) {
+    const { name } = args;
+    const trimmedName = name.trim();
+    if (!this.provider.has(trimmedName)) {
+      const available = this.provider.names();
+      const suggestion = available.length > 0 ? `Available skills: ${available.join(", ")}` : "No skills are currently loaded.";
+      return {
+        success: false,
+        output: "",
+        error: `Skill "${trimmedName}" not found. ${suggestion}`
+      };
+    }
+    const body = this.provider.getSkillContext(trimmedName);
+    if (!body) {
+      return {
+        success: false,
+        output: "",
+        error: `Skill "${trimmedName}" exists but has no content.`
+      };
+    }
+    return {
+      success: true,
+      output: `# Skill: ${trimmedName}
+
+${body}`,
+      metadata: {
+        skillName: trimmedName,
+        bodyLength: body.length
+      }
+    };
+  }
+};
+var ToolRegistry = class _ToolRegistry {
+  tools = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool. Throws if a tool with the same name is already registered.
+   */
+  register(tool) {
+    if (this.tools.has(tool.name)) {
+      throw new ToolError(
+        `Tool "${tool.name}" is already registered.`,
+        tool.name
+      );
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Get a tool by name. Returns undefined if not found.
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Check whether a tool is registered.
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * List all registered tools.
+   */
+  list() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * List tool names.
+   */
+  names() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Get tools filtered by weight classification.
+   */
+  byWeight(weight) {
+    return this.list().filter((t) => t.weight === weight);
+  }
+  /**
+   * Unregister a tool by name. Returns true if removed, false if not found.
+   */
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  /**
+   * Convert all registered tools to ToolDefinition[] for LLM consumption.
+   * This is the format expected by provider stream/complete calls.
+   */
+  getToolDefinitions(filterNames) {
+    const tools = filterNames ? this.list().filter((t) => filterNames.includes(t.name)) : this.list();
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }));
+  }
+  /**
+   * Get the count of registered tools.
+   */
+  get size() {
+    return this.tools.size;
+  }
+  /**
+   * Create a registry with the default set of built-in tools.
+   *
+   * Options:
+   * - exclude: tool names to exclude from the default set
+   * - include: if provided, only these tools are included (overrides exclude)
+   */
+  static createDefault(opts) {
+    const registry = new _ToolRegistry();
+    const allTools = [
+      new BashTool(),
+      new FileReadTool(),
+      new FileWriteTool(),
+      new FileEditTool(),
+      new GrepTool(),
+      new GlobTool(),
+      new WebFetchTool(),
+      new WebSearchTool(),
+      new MemoryStoreTool(),
+      new MemoryRecallTool(),
+      new DelegateTool(),
+      new MeshTool(),
+      new BrowserTool()
+    ];
+    for (const tool of allTools) {
+      if (opts?.include) {
+        if (opts.include.includes(tool.name)) {
+          registry.register(tool);
+        }
+      } else if (opts?.exclude) {
+        if (!opts.exclude.includes(tool.name)) {
+          registry.register(tool);
+        }
+      } else {
+        registry.register(tool);
+      }
+    }
+    return registry;
+  }
+};
+
+export {
+  LoadSkillTool,
+  ToolRegistry
+};