anycodex 0.0.1 → 0.0.2

package/dist/chunk-XU2SE4LZ.js

@@ -0,0 +1,3864 @@
+#!/usr/bin/env node
+import {
+  LSP,
+  MessageV2,
+  ModelID,
+  ProviderID,
+  Todo,
+  iife
+} from "./chunk-TDYQG5PB.js";
+import {
+  Identifier,
+  MessageID,
+  PartID
+} from "./chunk-ZXPWUU3S.js";
+import {
+  Filesystem,
+  Flag,
+  Log,
+  NamedError,
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  relative,
+  resolve
+} from "./chunk-6DDCZPRP.js";
+import {
+  Glob
+} from "./chunk-HULFFF7R.js";
+import {
+  withStatics
+} from "./chunk-KB4MYP36.js";
+import {
+  __callDispose,
+  __using
+} from "./chunk-XXVDY7BO.js";
+
+// ../agent/dist/chunk-CJTWJATG.js
+import z3 from "zod";
+import z2 from "zod";
+import { Schema } from "effect";
+import z from "zod";
+import z4 from "zod";
+import z5 from "zod";
+import { createTwoFilesPatch, diffLines } from "diff";
+import z6 from "zod";
+import z7 from "zod";
+import z8 from "zod";
+import z9 from "zod";
+import z10 from "zod";
+import z11 from "zod";
+import z12 from "zod";
+import TurndownService from "turndown";
+import z13 from "zod";
+import { createTwoFilesPatch as createTwoFilesPatch2 } from "diff";
+import z14 from "zod";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import z17 from "zod";
+import z16 from "zod";
+import matter from "gray-matter";
+import { z as z15 } from "zod";
+import { pathToFileURL } from "url";
+import z25 from "zod";
+import z18 from "zod";
+import z19 from "zod";
+import z21 from "zod";
+import z20 from "zod";
+import { createTwoFilesPatch as createTwoFilesPatch3, diffLines as diffLines2 } from "diff";
+import z22 from "zod";
+import z23 from "zod";
+import z24 from "zod";
+var SchedulerService = class {
+  log = Log.create({ service: "scheduler" });
+  tasks = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  register(task) {
+    const current = this.timers.get(task.id);
+    if (current) clearInterval(current);
+    this.tasks.set(task.id, task);
+    void this.run(task);
+    const timer = setInterval(() => {
+      void this.run(task);
+    }, task.interval);
+    timer.unref();
+    this.timers.set(task.id, timer);
+  }
+  async run(task) {
+    this.log.info("run", { id: task.id });
+    await task.run().catch((error) => {
+      this.log.error("run failed", { id: task.id, error });
+    });
+  }
+  dispose() {
+    for (const timer of this.timers.values()) {
+      clearInterval(timer);
+    }
+    this.tasks.clear();
+    this.timers.clear();
+  }
+};
+var shared = new SchedulerService();
+var Scheduler;
+((Scheduler2) => {
+  function state(context) {
+    if (context.scheduler) return context.scheduler;
+    return context.scheduler;
+  }
+  function register(context, task) {
+    const scope = task.scope ?? "instance";
+    const svc = scope === "global" ? shared : context.scheduler;
+    if (scope === "global" && svc === shared) {
+      const existing = shared.timers?.get(task.id);
+      if (existing) return;
+    }
+    svc.register(task);
+  }
+  Scheduler2.register = register;
+})(Scheduler || (Scheduler = {}));
+var toolIdSchema = Schema.String.pipe(Schema.brand("ToolID"));
+var ToolID = toolIdSchema.pipe(
+  withStatics((schema) => ({
+    make: (id) => schema.makeUnsafe(id),
+    ascending: (id) => schema.makeUnsafe(Identifier.ascending("tool", id)),
+    zod: Identifier.schema("tool").pipe(z.custom())
+  }))
+);
+var Truncate;
+((Truncate2) => {
+  Truncate2.MAX_LINES = 2e3;
+  Truncate2.MAX_BYTES = 50 * 1024;
+  function dir(context) {
+    return join(context.dataPath, "tool-output");
+  }
+  Truncate2.dir = dir;
+  function glob(context) {
+    return context ? join(dir(context), "*") : join("tool-output", "*");
+  }
+  Truncate2.glob = glob;
+  const RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+  const HOUR_MS = 60 * 60 * 1e3;
+  function init(context) {
+    Scheduler.register(context, {
+      id: "tool.truncation.cleanup",
+      interval: HOUR_MS,
+      run: cleanup,
+      scope: "global"
+    });
+  }
+  Truncate2.init = init;
+  async function cleanup(context) {
+    if (!context) return;
+    const cutoff = Identifier.timestamp(Identifier.create("tool", false, Date.now() - RETENTION_MS));
+    const entries = await Glob.scan(context, "tool_*", { cwd: dir(context), include: "file" }).catch(() => []);
+    for (const entry of entries) {
+      if (Identifier.timestamp(entry) >= cutoff) continue;
+      await Filesystem.remove(context, join(dir(context), entry)).catch(() => {
+      });
+    }
+  }
+  Truncate2.cleanup = cleanup;
+  async function output(context, text, options = {}, agent) {
+    const maxLines = options.maxLines ?? Truncate2.MAX_LINES;
+    const maxBytes = options.maxBytes ?? Truncate2.MAX_BYTES;
+    const direction = options.direction ?? "head";
+    const lines = text.split("\n");
+    const totalBytes = Buffer.byteLength(text, "utf-8");
+    if (lines.length <= maxLines && totalBytes <= maxBytes) {
+      return { content: text, truncated: false };
+    }
+    const out = [];
+    let i = 0;
+    let bytes = 0;
+    let hitBytes = false;
+    if (direction === "head") {
+      for (i = 0; i < lines.length && i < maxLines; i++) {
+        const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0);
+        if (bytes + size > maxBytes) {
+          hitBytes = true;
+          break;
+        }
+        out.push(lines[i]);
+        bytes += size;
+      }
+    } else {
+      for (i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
+        const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0);
+        if (bytes + size > maxBytes) {
+          hitBytes = true;
+          break;
+        }
+        out.unshift(lines[i]);
+        bytes += size;
+      }
+    }
+    const removed = hitBytes ? totalBytes - bytes : lines.length - out.length;
+    const unit = hitBytes ? "bytes" : "lines";
+    const preview = out.join("\n");
+    const id = ToolID.ascending();
+    const filepath = join(dir(context), id);
+    await Filesystem.write(context, filepath, text);
+    const hint = `The tool call succeeded but the output was truncated. Full output saved to: ${filepath}
+Use Grep to search the full content or Read with offset/limit to view specific sections.`;
+    const message = direction === "head" ? `${preview}
+
+...${removed} ${unit} truncated...
+
+${hint}` : `...${removed} ${unit} truncated...
+
+${hint}
+
+${preview}`;
+    return { content: message, truncated: true, outputPath: filepath };
+  }
+  Truncate2.output = output;
+})(Truncate || (Truncate = {}));
+var Tool;
+((Tool2) => {
+  function define(id, init) {
+    return {
+      id,
+      init: async (initCtx) => {
+        const toolInfo = init instanceof Function ? await init(initCtx) : init;
+        const execute = toolInfo.execute;
+        toolInfo.execute = async (args, ctx) => {
+          try {
+            toolInfo.parameters.parse(args);
+          } catch (error) {
+            if (error instanceof z2.ZodError && toolInfo.formatValidationError) {
+              throw new Error(toolInfo.formatValidationError(error), { cause: error });
+            }
+            throw new Error(
+              `The ${id} tool was called with invalid arguments: ${error}.
+Please rewrite the input so it satisfies the expected schema.`,
+              { cause: error }
+            );
+          }
+          const result = await execute(args, ctx);
+          if (result.metadata.truncated !== void 0) {
+            return result;
+          }
+          const truncated = await Truncate.output(ctx, result.output, {}, initCtx?.agent);
+          return {
+            ...result,
+            output: truncated.content,
+            metadata: {
+              ...result.metadata,
+              truncated: truncated.truncated,
+              ...truncated.truncated && { outputPath: truncated.outputPath }
+            }
+          };
+        };
+        return toolInfo;
+      }
+    };
+  }
+  Tool2.define = define;
+})(Tool || (Tool = {}));
+var plan_exit_txt_default = `Use this tool when you have completed the planning phase and are ready to exit plan agent.
+
+This tool will ask the user if they want to switch to build agent to start implementing the plan.
+
+Call this tool:
+- After you have written a complete plan to the plan file
+- After you have clarified any questions with the user
+- When you are confident the plan is ready for implementation
+
+Do NOT call this tool:
+- Before you have created or finalized the plan
+- If you still have unanswered questions about the implementation
+- If the user has indicated they want to continue planning
+`;
+async function getLastModel(context, sessionID) {
+  for await (const item of MessageV2.stream(context, sessionID)) {
+    if (item.info.role === "user" && item.info.model) return item.info.model;
+  }
+  return context.provider.defaultModel();
+}
+var PlanExitTool = Tool.define("plan_exit", {
+  description: plan_exit_txt_default,
+  parameters: z3.object({}),
+  async execute(_params, ctx) {
+    const session = await ctx.session.get(ctx.sessionID);
+    const plan = relative(ctx.worktree, ctx.session.plan(session));
+    const model = await getLastModel(ctx, ctx.sessionID);
+    const userMsg = {
+      id: MessageID.ascending(),
+      sessionID: ctx.sessionID,
+      role: "user",
+      time: {
+        created: Date.now()
+      },
+      agent: "build",
+      model
+    };
+    await ctx.session.updateMessage(userMsg);
+    await ctx.session.updatePart({
+      id: PartID.ascending(),
+      messageID: userMsg.id,
+      sessionID: ctx.sessionID,
+      type: "text",
+      text: `The plan at ${plan} has been approved, you can now edit files. Execute the plan`,
+      synthetic: true
+    });
+    return {
+      title: "Switching to build agent",
+      output: "User approved switching to build agent. Wait for further instructions.",
+      metadata: {}
+    };
+  }
+});
+var bash_txt_default = `Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.
+
+All commands run in \${directory} by default. Use the \`workdir\` parameter if you need to run a command in a different directory. AVOID using \`cd <directory> && <command>\` patterns - use \`workdir\` instead.
+
+IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.
+
+Before executing the command, please follow these steps:
+
+1. Directory Verification:
+   - If the command will create new directories or files, first use \`ls\` to verify the parent directory exists and is the correct location
+   - For example, before running "mkdir foo/bar", first use \`ls foo\` to check that "foo" exists and is the intended parent directory
+
+2. Command Execution:
+   - Always quote file paths that contain spaces with double quotes (e.g., rm "path with spaces/file.txt")
+   - Examples of proper quoting:
+     - mkdir "/Users/name/My Documents" (correct)
+     - mkdir /Users/name/My Documents (incorrect - will fail)
+     - python "/path/with spaces/script.py" (correct)
+     - python /path/with spaces/script.py (incorrect - will fail)
+   - After ensuring proper quoting, execute the command.
+   - Capture the output of the command.
+
+Usage notes:
+  - The command argument is required.
+  - You can specify an optional timeout in milliseconds. If not specified, commands will time out after 120000ms (2 minutes).
+  - It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
+  - If the output exceeds \${maxLines} lines or \${maxBytes} bytes, it will be truncated and the full output will be written to a file. You can use Read with offset/limit to read specific sections or Grep to search the full content. Do NOT use \`head\`, \`tail\`, or other truncation commands to limit output; the full output will already be captured to a file for more precise searching.
+
+  - Avoid using Bash with the \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or when these commands are truly necessary for the task. Instead, always prefer using the dedicated tools for these commands:
+    - File search: Use Glob (NOT find or ls)
+    - Content search: Use Grep (NOT grep or rg)
+    - Read files: Use Read (NOT cat/head/tail)
+    - Edit files: Use Edit (NOT sed/awk)
+    - Write files: Use Write (NOT echo >/cat <<EOF)
+    - Communication: Output text directly (NOT echo/printf)
+  - When issuing multiple commands:
+    - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message. For example, if you need to run "git status" and "git diff", send a single message with two Bash tool calls in parallel.
+    - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together (e.g., \`git add . && git commit -m "message" && git push\`). For instance, if one operation must complete before another starts (like mkdir before cp, Write before Bash for git operations, or git add before git commit), run these operations sequentially instead.
+    - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
+    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)
+  - AVOID using \`cd <directory> && <command>\`. Use the \`workdir\` parameter to change directories instead.
+    <good-example>
+    Use workdir="/foo/bar" with command: pytest tests
+    </good-example>
+    <bad-example>
+    cd /foo/bar && pytest tests
+    </bad-example>
+
+# Committing changes with git
+
+Only create commits when requested by the user. If unclear, ask first. When the user asks you to create a new git commit, follow these steps carefully:
+
+Git Safety Protocol:
+- NEVER update the git config
+- NEVER run destructive/irreversible git commands (like push --force, hard reset, etc) unless the user explicitly requests them
+- NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it
+- NEVER run force push to main/master, warn the user if they request it
+- Avoid git commit --amend. ONLY use --amend when ALL conditions are met:
+  (1) User explicitly requested amend, OR commit SUCCEEDED but pre-commit hook auto-modified files that need including
+  (2) HEAD commit was created by you in this conversation (verify: git log -1 --format='%an %ae')
+  (3) Commit has NOT been pushed to remote (verify: git status shows "Your branch is ahead")
+- CRITICAL: If commit FAILED or was REJECTED by hook, NEVER amend - fix the issue and create a NEW commit
+- CRITICAL: If you already pushed to remote, NEVER amend unless user explicitly requests it (requires force push)
+- NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
+
+1. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following bash commands in parallel, each using the Bash tool:
+  - Run a git status command to see all untracked files.
+  - Run a git diff command to see both staged and unstaged changes that will be committed.
+  - Run a git log command to see recent commit messages, so that you can follow this repository's commit message style.
+2. Analyze all staged changes (both previously staged and newly added) and draft a commit message:
+  - Summarize the nature of the changes (eg. new feature, enhancement to an existing feature, bug fix, refactoring, test, docs, etc.). Ensure the message accurately reflects the changes and their purpose (i.e. "add" means a wholly new feature, "update" means an enhancement to an existing feature, "fix" means a bug fix, etc.).
+  - Do not commit files that likely contain secrets (.env, credentials.json, etc.). Warn the user if they specifically request to commit those files
+  - Draft a concise (1-2 sentences) commit message that focuses on the "why" rather than the "what"
+  - Ensure it accurately reflects the changes and their purpose
+3. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following commands:
+   - Add relevant untracked files to the staging area.
+   - Create the commit with a message
+   - Run git status after the commit completes to verify success.
+   Note: git status depends on the commit completing, so run it sequentially after the commit.
+4. If the commit fails due to pre-commit hook, fix the issue and create a NEW commit (see amend rules above)
+
+Important notes:
+- NEVER run additional commands to read or explore code, besides git bash commands
+- NEVER use the TodoWrite or Task tools
+- DO NOT push to the remote repository unless the user explicitly asks you to do so
+- IMPORTANT: Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported.
+- If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit
+
+# Creating pull requests
+Use the gh command via the Bash tool for ALL GitHub-related tasks including working with issues, pull requests, checks, and releases. If given a GitHub URL use the gh command to get the information needed.
+
+IMPORTANT: When the user asks you to create a pull request, follow these steps carefully:
+
+1. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following bash commands in parallel using the Bash tool, in order to understand the current state of the branch since it diverged from the main branch:
+   - Run a git status command to see all untracked files
+   - Run a git diff command to see both staged and unstaged changes that will be committed
+   - Check if the current branch tracks a remote branch and is up to date with the remote, so you know if you need to push to the remote
+   - Run a git log command and \`git diff [base-branch]...HEAD\` to understand the full commit history for the current branch (from the time it diverged from the base branch)
+2. Analyze all changes that will be included in the pull request, making sure to look at all relevant commits (NOT just the latest commit, but ALL commits that will be included in the pull request!!!), and draft a pull request summary
+3. You can call multiple tools in a single response. When multiple independent pieces of information are requested and all commands are likely to succeed, run multiple tool calls in parallel for optimal performance. run the following commands in parallel:
+   - Create new branch if needed
+   - Push to remote with -u flag if needed
+   - Create PR using gh pr create with the format below. Use a HEREDOC to pass the body to ensure correct formatting.
+<example>
+gh pr create --title "the pr title" --body "$(cat <<'EOF'
+## Summary
+<1-3 bullet points>
+</example>
+
+Important:
+- DO NOT use the TodoWrite or Task tools
+- Return the PR URL when you're done, so the user can see it
+
+# Other common operations
+- View comments on a GitHub PR: gh api repos/foo/bar/pulls/123/comments
+`;
+var MAX_METADATA_LENGTH = 3e4;
+var DEFAULT_TIMEOUT = Flag.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS || 2 * 60 * 1e3;
+var log = Log.create({ service: "bash-tool" });
+function parseBashCommands(input) {
+  const results = [];
+  const segments = input.split(/\s*(?:&&|\|\||[;|\n])\s*/);
+  for (const segment of segments) {
+    const trimmed = segment.trim();
+    if (!trimmed) continue;
+    const words = tokenize(trimmed);
+    if (words.length > 0) {
+      results.push({ text: trimmed, words });
+    }
+  }
+  return results;
+}
+function tokenize(input) {
+  const words = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let escape = false;
+  for (const ch of input) {
+    if (escape) {
+      current += ch;
+      escape = false;
+      continue;
+    }
+    if (ch === "\\" && !inSingle) {
+      escape = true;
+      continue;
+    }
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (/\s/.test(ch) && !inSingle && !inDouble) {
+      if (current) {
+        words.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (current) words.push(current);
+  return words;
+}
+var BashTool = Tool.define("bash", async (initCtx) => {
+  return {
+    description: bash_txt_default.replaceAll("${directory}", initCtx?.directory || "").replaceAll("${maxLines}", String(Truncate.MAX_LINES)).replaceAll("${maxBytes}", String(Truncate.MAX_BYTES)),
+    parameters: z4.object({
+      command: z4.string().describe("The command to execute"),
+      timeout: z4.number().describe("Optional timeout in milliseconds").optional(),
+      workdir: z4.string().describe(
+        `The working directory to run the command in. Defaults to ${initCtx?.directory || ""}. Use this instead of 'cd' commands.`
+      ).optional(),
+      description: z4.string().describe(
+        "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'"
+      )
+    }),
+    async execute(params, ctx) {
+      const cwd = params.workdir || ctx.directory;
+      if (params.timeout !== void 0 && params.timeout < 0) {
+        throw new Error(`Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`);
+      }
+      const timeout = params.timeout ?? DEFAULT_TIMEOUT;
+      const commands = parseBashCommands(params.command);
+      const directories = /* @__PURE__ */ new Set();
+      if (!ctx.containsPath(cwd)) directories.add(cwd);
+      const patterns = /* @__PURE__ */ new Set();
+      const always = /* @__PURE__ */ new Set();
+      for (const cmd of commands) {
+        if (!cmd.words.length) continue;
+        const [name, ...args] = cmd.words;
+        if (["cd", "rm", "cp", "mv", "mkdir", "touch", "chmod", "chown", "cat"].includes(name)) {
+          for (const arg of args) {
+            if (arg.startsWith("-") || name === "chmod" && arg.startsWith("+")) continue;
+            const resolved = Filesystem.resolve(resolve(cwd, arg));
+            log.info("resolved path", { arg, resolved });
+            if (resolved) {
+              if (!ctx.containsPath(resolved)) {
+                const dir = await Filesystem.isDir(ctx, resolved) ? resolved : dirname(resolved);
+                directories.add(dir);
+              }
+            }
+          }
+        }
+        if (name !== "cd") {
+          patterns.add(cmd.text);
+          always.add(name + " *");
+        }
+      }
+      if (directories.size > 0) {
+        const globs = Array.from(directories).map((dir) => {
+          if (dir.startsWith("/")) return `${dir.replace(/[\\/]+$/, "")}/*`;
+          return join(dir, "*");
+        });
+        await ctx.ask({
+          permission: "external_directory",
+          patterns: globs,
+          always: globs,
+          metadata: {}
+        });
+      }
+      if (patterns.size > 0) {
+        await ctx.ask({
+          permission: "bash",
+          patterns: Array.from(patterns),
+          always: Array.from(always),
+          metadata: {}
+        });
+      }
+      const proc = ctx.shell.spawn(params.command, {
+        cwd,
+        env: {}
+      });
+      let output = "";
+      ctx.metadata({
+        metadata: {
+          output: "",
+          description: params.description
+        }
+      });
+      const append = (chunk) => {
+        output += chunk.toString();
+        ctx.metadata({
+          metadata: {
+            output: output.length > MAX_METADATA_LENGTH ? output.slice(0, MAX_METADATA_LENGTH) + "\n\n..." : output,
+            description: params.description
+          }
+        });
+      };
+      proc.stdout?.on("data", append);
+      proc.stderr?.on("data", append);
+      let timedOut = false;
+      let aborted = false;
+      let exited = false;
+      const kill = () => ctx.shell.kill(proc, { exited: () => exited });
+      if (ctx.abort.aborted) {
+        aborted = true;
+        await kill();
+      }
+      const abortHandler = () => {
+        aborted = true;
+        void kill();
+      };
+      ctx.abort.addEventListener("abort", abortHandler, { once: true });
+      const timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        void kill();
+      }, timeout + 100);
+      await new Promise((resolve2, reject) => {
+        const cleanup = () => {
+          clearTimeout(timeoutTimer);
+          ctx.abort.removeEventListener("abort", abortHandler);
+        };
+        proc.once("exit", () => {
+          exited = true;
+          cleanup();
+          resolve2();
+        });
+        proc.once("error", (error) => {
+          exited = true;
+          cleanup();
+          reject(error);
+        });
+      });
+      const resultMetadata = [];
+      if (timedOut) {
+        resultMetadata.push(`bash tool terminated command after exceeding timeout ${timeout} ms`);
+      }
+      if (aborted) {
+        resultMetadata.push("User aborted the command");
+      }
+      if (resultMetadata.length > 0) {
+        output += "\n\n<bash_metadata>\n" + resultMetadata.join("\n") + "\n</bash_metadata>";
+      }
+      return {
+        title: params.description,
+        metadata: {
+          output: output.length > MAX_METADATA_LENGTH ? output.slice(0, MAX_METADATA_LENGTH) + "\n\n..." : output,
+          exit: proc.exitCode,
+          description: params.description
+        },
+        output
+      };
+    }
+  };
+});
+var edit_txt_default = `Performs exact string replacements in files. 
+
+Usage:
+- You must use your \`Read\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + colon + space (e.g., \`1: \`). Everything after that space is the actual file content to match. Never include any part of the line number prefix in the oldString or newString.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`oldString\` is not found in the file with an error "oldString not found in content".
+- The edit will FAIL if \`oldString\` is found multiple times in the file with an error "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match." Either provide a larger string with more surrounding context to make it unique or use \`replaceAll\` to change every instance of \`oldString\`. 
+- Use \`replaceAll\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.
+`;
+async function assertExternalDirectory(ctx, target, options) {
+  if (!target) return;
+  if (options?.bypass) return;
+  if (ctx.containsPath(target)) return;
+  const kind = options?.kind ?? "file";
+  const parentDir = kind === "directory" ? target : dirname(target);
+  const glob = join(parentDir, "*").replaceAll("\\", "/");
+  await ctx.ask({
+    permission: "external_directory",
+    patterns: [glob],
+    always: [glob],
+    metadata: {
+      filepath: target,
+      parentDir
+    }
+  });
+}
+var MAX_DIAGNOSTICS_PER_FILE = 20;
+function normalizeLineEndings(text) {
+  return text.replaceAll("\r\n", "\n");
+}
+function detectLineEnding(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function convertToLineEnding(text, ending) {
+  if (ending === "\n") return text;
+  return text.replaceAll("\n", "\r\n");
+}
+var EditTool = Tool.define("edit", {
+  description: edit_txt_default,
+  parameters: z5.object({
+    filePath: z5.string().describe("The absolute path to the file to modify"),
+    oldString: z5.string().describe("The text to replace"),
+    newString: z5.string().describe("The text to replace it with (must be different from oldString)"),
+    replaceAll: z5.boolean().optional().describe("Replace all occurrences of oldString (default false)")
+  }),
+  async execute(params, ctx) {
+    if (!params.filePath) {
+      throw new Error("filePath is required");
+    }
+    if (params.oldString === params.newString) {
+      throw new Error("No changes to apply: oldString and newString are identical.");
+    }
+    const filePath = isAbsolute(params.filePath) ? params.filePath : join(ctx.directory, params.filePath);
+    await assertExternalDirectory(ctx, filePath);
+    let diff = "";
+    let contentOld = "";
+    let contentNew = "";
+    await ctx.fileTime.withLock(filePath, async () => {
+      if (params.oldString === "") {
+        const existed = await ctx.fs.exists(filePath);
+        contentNew = params.newString;
+        diff = trimDiff(createTwoFilesPatch(filePath, filePath, contentOld, contentNew));
+        await ctx.ask({
+          permission: "edit",
+          patterns: [relative(ctx.worktree, filePath)],
+          always: ["*"],
+          metadata: {
+            filepath: filePath,
+            diff
+          }
+        });
+        await ctx.fs.write(filePath, params.newString);
+        ctx.emit("file.edited", { file: filePath });
+        ctx.fileTime.read(ctx.sessionID, filePath);
+        return;
+      }
+      const stats = await ctx.fs.stat(filePath);
+      if (!stats) throw new Error(`File ${filePath} not found`);
+      if (stats.isDirectory) throw new Error(`Path is a directory, not a file: ${filePath}`);
+      await ctx.fileTime.assert(ctx, ctx.sessionID, filePath);
+      contentOld = await ctx.fs.readText(filePath);
+      const ending = detectLineEnding(contentOld);
+      const old = convertToLineEnding(normalizeLineEndings(params.oldString), ending);
+      const next = convertToLineEnding(normalizeLineEndings(params.newString), ending);
+      contentNew = replace(contentOld, old, next, params.replaceAll);
+      diff = trimDiff(
+        createTwoFilesPatch(filePath, filePath, normalizeLineEndings(contentOld), normalizeLineEndings(contentNew))
+      );
+      await ctx.ask({
+        permission: "edit",
+        patterns: [relative(ctx.worktree, filePath)],
+        always: ["*"],
+        metadata: {
+          filepath: filePath,
+          diff
+        }
+      });
+      await ctx.fs.write(filePath, contentNew);
+      ctx.emit("file.edited", { file: filePath });
+      contentNew = await ctx.fs.readText(filePath);
+      diff = trimDiff(
+        createTwoFilesPatch(filePath, filePath, normalizeLineEndings(contentOld), normalizeLineEndings(contentNew))
+      );
+      ctx.fileTime.read(ctx.sessionID, filePath);
+    });
+    const filediff = {
+      file: filePath,
+      before: contentOld,
+      after: contentNew,
+      additions: 0,
+      deletions: 0
+    };
+    for (const change of diffLines(contentOld, contentNew)) {
+      if (change.added) filediff.additions += change.count || 0;
+      if (change.removed) filediff.deletions += change.count || 0;
+    }
+    ctx.metadata({
+      metadata: {
+        diff,
+        filediff,
+        diagnostics: {}
+      }
+    });
+    let output = "Edit applied successfully.";
+    await LSP.touchFile(filePath, true);
+    const diagnostics = await LSP.diagnostics();
+    const normalizedFilePath = filePath;
+    const issues = diagnostics.get(normalizedFilePath) ?? [];
+    const errors = issues.filter((item) => item.severity === 1);
+    if (errors.length > 0) {
+      const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE);
+      const suffix = errors.length > MAX_DIAGNOSTICS_PER_FILE ? `
+... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more` : "";
+      output += `
+
+LSP errors detected in this file, please fix:
+<diagnostics file="${filePath}">
+${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
+</diagnostics>`;
+    }
+    return {
+      metadata: {
+        diagnostics,
+        diff,
+        filediff
+      },
+      title: `${relative(ctx.worktree, filePath)}`,
+      output
+    };
+  }
+});
+var SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0;
+var MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
+function levenshtein(a, b) {
+  if (a === "" || b === "") {
+    return Math.max(a.length, b.length);
+  }
+  const matrix = Array.from(
+    { length: a.length + 1 },
+    (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+  return matrix[a.length][b.length];
+}
+var SimpleReplacer = function* (_content, find) {
+  yield find;
+};
+var LineTrimmedReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines[searchLines.length - 1] === "") {
+    searchLines.pop();
+  }
+  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+    let matches = true;
+    for (let j = 0; j < searchLines.length; j++) {
+      const originalTrimmed = originalLines[i + j].trim();
+      const searchTrimmed = searchLines[j].trim();
+      if (originalTrimmed !== searchTrimmed) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      let matchStartIndex = 0;
+      for (let k = 0; k < i; k++) {
+        matchStartIndex += originalLines[k].length + 1;
+      }
+      let matchEndIndex = matchStartIndex;
+      for (let k = 0; k < searchLines.length; k++) {
+        matchEndIndex += originalLines[i + k].length;
+        if (k < searchLines.length - 1) {
+          matchEndIndex += 1;
+        }
+      }
+      yield content.substring(matchStartIndex, matchEndIndex);
+    }
+  }
+};
+var BlockAnchorReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines.length < 3) {
+    return;
+  }
+  if (searchLines[searchLines.length - 1] === "") {
+    searchLines.pop();
+  }
+  const firstLineSearch = searchLines[0].trim();
+  const lastLineSearch = searchLines[searchLines.length - 1].trim();
+  const searchBlockSize = searchLines.length;
+  const candidates = [];
+  for (let i = 0; i < originalLines.length; i++) {
+    if (originalLines[i].trim() !== firstLineSearch) {
+      continue;
+    }
+    for (let j = i + 2; j < originalLines.length; j++) {
+      if (originalLines[j].trim() === lastLineSearch) {
+        candidates.push({ startLine: i, endLine: j });
+        break;
+      }
+    }
+  }
+  if (candidates.length === 0) {
+    return;
+  }
+  if (candidates.length === 1) {
+    const { startLine, endLine } = candidates[0];
+    const actualBlockSize = endLine - startLine + 1;
+    let similarity = 0;
+    let linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim();
+        const searchLine = searchLines[j].trim();
+        const maxLen = Math.max(originalLine.length, searchLine.length);
+        if (maxLen === 0) {
+          continue;
+        }
+        const distance = levenshtein(originalLine, searchLine);
+        similarity += (1 - distance / maxLen) / linesToCheck;
+        if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+          break;
+        }
+      }
+    } else {
+      similarity = 1;
+    }
+    if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+      let matchStartIndex = 0;
+      for (let k = 0; k < startLine; k++) {
+        matchStartIndex += originalLines[k].length + 1;
+      }
+      let matchEndIndex = matchStartIndex;
+      for (let k = startLine; k <= endLine; k++) {
+        matchEndIndex += originalLines[k].length;
+        if (k < endLine) {
+          matchEndIndex += 1;
+        }
+      }
+      yield content.substring(matchStartIndex, matchEndIndex);
+    }
+    return;
+  }
+  let bestMatch = null;
+  let maxSimilarity = -1;
+  for (const candidate of candidates) {
+    const { startLine, endLine } = candidate;
+    const actualBlockSize = endLine - startLine + 1;
+    let similarity = 0;
+    let linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim();
+        const searchLine = searchLines[j].trim();
+        const maxLen = Math.max(originalLine.length, searchLine.length);
+        if (maxLen === 0) {
+          continue;
+        }
+        const distance = levenshtein(originalLine, searchLine);
+        similarity += 1 - distance / maxLen;
+      }
+      similarity /= linesToCheck;
+    } else {
+      similarity = 1;
+    }
+    if (similarity > maxSimilarity) {
+      maxSimilarity = similarity;
+      bestMatch = candidate;
+    }
+  }
+  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+    const { startLine, endLine } = bestMatch;
+    let matchStartIndex = 0;
+    for (let k = 0; k < startLine; k++) {
+      matchStartIndex += originalLines[k].length + 1;
+    }
+    let matchEndIndex = matchStartIndex;
+    for (let k = startLine; k <= endLine; k++) {
+      matchEndIndex += originalLines[k].length;
+      if (k < endLine) {
+        matchEndIndex += 1;
+      }
+    }
+    yield content.substring(matchStartIndex, matchEndIndex);
+  }
+};
+var WhitespaceNormalizedReplacer = function* (content, find) {
+  const normalizeWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+  const normalizedFind = normalizeWhitespace(find);
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (normalizeWhitespace(line) === normalizedFind) {
+      yield line;
+    } else {
+      const normalizedLine = normalizeWhitespace(line);
+      if (normalizedLine.includes(normalizedFind)) {
+        const words = find.trim().split(/\s+/);
+        if (words.length > 0) {
+          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
+          try {
+            const regex = new RegExp(pattern);
+            const match = line.match(regex);
+            if (match) {
+              yield match[0];
+            }
+          } catch (e) {
+          }
+        }
+      }
+    }
+  }
+  const findLines = find.split("\n");
+  if (findLines.length > 1) {
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+      const block = lines.slice(i, i + findLines.length);
+      if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
+        yield block.join("\n");
+      }
+    }
+  }
+};
+var IndentationFlexibleReplacer = function* (content, find) {
+  const removeIndentation = (text) => {
+    const lines = text.split("\n");
+    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+    if (nonEmptyLines.length === 0) return text;
+    const minIndent = Math.min(
+      ...nonEmptyLines.map((line) => {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+      })
+    );
+    return lines.map((line) => line.trim().length === 0 ? line : line.slice(minIndent)).join("\n");
+  };
+  const normalizedFind = removeIndentation(find);
+  const contentLines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    const block = contentLines.slice(i, i + findLines.length).join("\n");
+    if (removeIndentation(block) === normalizedFind) {
+      yield block;
+    }
+  }
+};
+var EscapeNormalizedReplacer = function* (content, find) {
+  const unescapeString = (str) => {
+    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
+      switch (capturedChar) {
+        case "n":
+          return "\n";
+        case "t":
+          return "	";
+        case "r":
+          return "\r";
+        case "'":
+          return "'";
+        case '"':
+          return '"';
+        case "`":
+          return "`";
+        case "\\":
+          return "\\";
+        case "\n":
+          return "\n";
+        case "$":
+          return "$";
+        default:
+          return match;
+      }
+    });
+  };
+  const unescapedFind = unescapeString(find);
+  if (content.includes(unescapedFind)) {
+    yield unescapedFind;
+  }
+  const lines = content.split("\n");
+  const findLines = unescapedFind.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    const unescapedBlock = unescapeString(block);
+    if (unescapedBlock === unescapedFind) {
+      yield block;
+    }
+  }
+};
+var MultiOccurrenceReplacer = function* (content, find) {
+  let startIndex = 0;
+  while (true) {
+    const index = content.indexOf(find, startIndex);
+    if (index === -1) break;
+    yield find;
+    startIndex = index + find.length;
+  }
+};
+var TrimmedBoundaryReplacer = function* (content, find) {
+  const trimmedFind = find.trim();
+  if (trimmedFind === find) {
+    return;
+  }
+  if (content.includes(trimmedFind)) {
+    yield trimmedFind;
+  }
+  const lines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    if (block.trim() === trimmedFind) {
+      yield block;
+    }
+  }
+};
+var ContextAwareReplacer = function* (content, find) {
+  const findLines = find.split("\n");
+  if (findLines.length < 3) {
+    return;
+  }
+  if (findLines[findLines.length - 1] === "") {
+    findLines.pop();
+  }
+  const contentLines = content.split("\n");
+  const firstLine = findLines[0].trim();
+  const lastLine = findLines[findLines.length - 1].trim();
+  for (let i = 0; i < contentLines.length; i++) {
+    if (contentLines[i].trim() !== firstLine) continue;
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        const blockLines = contentLines.slice(i, j + 1);
+        const block = blockLines.join("\n");
+        if (blockLines.length === findLines.length) {
+          let matchingLines = 0;
+          let totalNonEmptyLines = 0;
+          for (let k = 1; k < blockLines.length - 1; k++) {
+            const blockLine = blockLines[k].trim();
+            const findLine = findLines[k].trim();
+            if (blockLine.length > 0 || findLine.length > 0) {
+              totalNonEmptyLines++;
+              if (blockLine === findLine) {
+                matchingLines++;
+              }
+            }
+          }
+          if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
+            yield block;
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+};
+function trimDiff(diff) {
+  const lines = diff.split("\n");
+  const contentLines = lines.filter(
+    (line) => (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++")
+  );
+  if (contentLines.length === 0) return diff;
+  let min = Infinity;
+  for (const line of contentLines) {
+    const content = line.slice(1);
+    if (content.trim().length > 0) {
+      const match = content.match(/^(\s*)/);
+      if (match) min = Math.min(min, match[1].length);
+    }
+  }
+  if (min === Infinity || min === 0) return diff;
+  const trimmedLines = lines.map((line) => {
+    if ((line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) && !line.startsWith("---") && !line.startsWith("+++")) {
+      const prefix = line[0];
+      const content = line.slice(1);
+      return prefix + content.slice(min);
+    }
+    return line;
+  });
+  return trimmedLines.join("\n");
+}
+function replace(content, oldString, newString, replaceAll = false) {
+  if (oldString === newString) {
+    throw new Error("No changes to apply: oldString and newString are identical.");
+  }
+  let notFound = true;
+  for (const replacer of [
+    SimpleReplacer,
+    LineTrimmedReplacer,
+    BlockAnchorReplacer,
+    WhitespaceNormalizedReplacer,
+    IndentationFlexibleReplacer,
+    EscapeNormalizedReplacer,
+    TrimmedBoundaryReplacer,
+    ContextAwareReplacer,
+    MultiOccurrenceReplacer
+  ]) {
+    for (const search of replacer(content, oldString)) {
+      const index = content.indexOf(search);
+      if (index === -1) continue;
+      notFound = false;
+      if (replaceAll) {
+        return content.replaceAll(search, newString);
+      }
+      const lastIndex = content.lastIndexOf(search);
+      if (index !== lastIndex) continue;
+      return content.substring(0, index) + newString + content.substring(index + search.length);
+    }
+  }
+  if (notFound) {
+    throw new Error(
+      "Could not find oldString in the file. It must match exactly, including whitespace, indentation, and line endings."
+    );
+  }
+  throw new Error("Found multiple matches for oldString. Provide more surrounding context to make the match unique.");
+}
+var glob_txt_default = `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.
+`;
+var GlobTool = Tool.define("glob", {
+  description: glob_txt_default,
+  parameters: z6.object({
+    pattern: z6.string().describe("The glob pattern to match files against"),
+    path: z6.string().optional().describe(
+      `The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`
+    )
+  }),
+  async execute(params, ctx) {
+    await ctx.ask({
+      permission: "glob",
+      patterns: [params.pattern],
+      always: ["*"],
+      metadata: {
+        pattern: params.pattern,
+        path: params.path
+      }
+    });
+    let search = params.path ?? ctx.directory;
+    search = isAbsolute(search) ? search : resolve(ctx.directory, search);
+    await assertExternalDirectory(ctx, search, { kind: "directory" });
+    const limit = 100;
+    if (!ctx.search) throw new Error("Search is not available.");
+    const filePaths = await ctx.search.listFiles({
+      cwd: search,
+      glob: [params.pattern],
+      limit: limit + 1,
+      // +1 to detect truncation
+      signal: ctx.abort
+    });
+    const truncated = filePaths.length > limit;
+    const displayPaths = truncated ? filePaths.slice(0, limit) : filePaths;
+    const files = [];
+    for (const file of displayPaths) {
+      const full = resolve(search, file);
+      const s = await ctx.fs.stat(full);
+      const stats = s?.mtimeMs ?? 0;
+      files.push({
+        path: full,
+        mtime: stats
+      });
+    }
+    files.sort((a, b) => b.mtime - a.mtime);
+    const output = [];
+    if (files.length === 0) output.push("No files found");
+    if (files.length > 0) {
+      output.push(...files.map((f) => f.path));
+      if (truncated) {
+        output.push("");
+        output.push(
+          `(Results are truncated: showing first ${limit} results. Consider using a more specific path or pattern.)`
+        );
+      }
+    }
+    return {
+      title: relative(ctx.worktree, search),
+      metadata: {
+        count: files.length,
+        truncated
+      },
+      output: output.join("\n")
+    };
+  }
+});
+var SetWorkingDirectoryTool = Tool.define("set_working_directory", {
+  description: `Use this tool to set the working directory for this session. The user will tell you which project or folder they want to work on. The directory must be an absolute path to an existing directory on the file system. After setting the directory, the full development environment (file browser, diff viewer, etc.) will become available.
+
+IMPORTANT: This tool can only be called ONCE per session. Once the working directory is set, it cannot be changed. If a working directory is already set, this tool will return an error.`,
+  parameters: z7.object({
+    directory: z7.string().describe("Absolute path to the project directory")
+  }),
+  async execute(params, ctx) {
+    const dir = params.directory;
+    if (ctx.worktree && ctx.worktree !== "") {
+      return {
+        title: "Already set",
+        output: `Working directory is already set to "${ctx.worktree}". It can only be set once per session.`,
+        metadata: {}
+      };
+    }
+    const stat = await ctx.fs.stat(dir);
+    if (!stat || !stat.isDirectory) {
+      return {
+        title: "Invalid path",
+        output: stat ? `"${dir}" is not a directory. Please provide a valid directory path.` : `Directory "${dir}" does not exist. Please provide a valid absolute path.`,
+        metadata: {}
+      };
+    }
+    ctx.emit("directory.set", { directory: dir });
+    return {
+      title: `Set directory: ${dir}`,
+      output: `Working directory set to "${dir}". The session is now configured to work on this project. The full development environment is now available.`,
+      metadata: {}
+    };
+  }
+});
+var MAX_LINE_LENGTH = 2e3;
+var GrepTool = Tool.define("grep", {
+  description: "Searches for a regex pattern in file contents within the current workspace.",
+  parameters: z8.object({
+    pattern: z8.string().describe("The regex pattern to search for in file contents"),
+    path: z8.string().optional().describe("The directory to search in. Defaults to the current working directory."),
+    include: z8.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")')
+  }),
+  async execute(params, ctx) {
+    if (!params.pattern) {
+      throw new Error("pattern is required");
+    }
+    await ctx.ask({
+      permission: "grep",
+      patterns: [params.pattern],
+      always: ["*"],
+      metadata: {
+        pattern: params.pattern,
+        path: params.path,
+        include: params.include
+      }
+    });
+    let searchPath = params.path ?? ctx.directory;
+    searchPath = isAbsolute(searchPath) ? searchPath : resolve(ctx.directory, searchPath);
+    await assertExternalDirectory(ctx, searchPath, { kind: "directory" });
+    if (!ctx.search) throw new Error("Search provider is required for the grep tool");
+    const matches = await ctx.search.grep({
+      pattern: params.pattern,
+      path: searchPath,
+      include: params.include,
+      maxLineLength: MAX_LINE_LENGTH,
+      signal: ctx.abort
+    });
+    if (matches.length === 0) {
+      return {
+        title: "grep",
+        metadata: {
+          count: 0,
+          files: 0,
+          truncated: false
+        },
+        output: "No results matched the specified pattern"
+      };
+    }
+    const totalMatches = matches.length;
+    const resultLimit = 100;
+    let filesCount = 0;
+    let fileMatches = [];
+    let currentFile = "";
+    let currentLines = [];
+    for (const match of matches) {
+      if (match.file !== currentFile) {
+        if (currentFile) {
+          fileMatches.push({ file: currentFile, lines: currentLines });
+          filesCount++;
+        }
+        currentFile = match.file;
+        currentLines = [];
+        if (filesCount >= resultLimit) break;
+      }
+      currentLines.push(match);
+    }
+    if (currentFile && filesCount < resultLimit) {
+      fileMatches.push({ file: currentFile, lines: currentLines });
+      filesCount++;
+    }
+    const truncated = filesCount >= resultLimit;
+    fileMatches.sort((a, b) => b.lines.length - a.lines.length);
+    if (fileMatches.length > 10) {
+      fileMatches = fileMatches.slice(0, 10);
+    }
+    const output = [];
+    if (filesCount > 10) {
+      output.push(
+        `(Showing top 10 files by number of matches. There are ${filesCount} files in total that match the pattern.)`,
+        ""
+      );
+    }
+    for (const fm of fileMatches) {
+      const matchLimit = 15;
+      output.push(`[${relative(ctx.worktree, fm.file)}]`);
+      for (const match of fm.lines.slice(0, matchLimit)) {
+        output.push(`  ${match.line}: ${match.content}`);
+      }
+      if (fm.lines.length > matchLimit) {
+        output.push(`  ... (${fm.lines.length - matchLimit} more matches in this file)`);
+      }
+      output.push("");
+    }
+    if (truncated) {
+      output.push(`...`);
+      output.push(`(Results have been truncated to the first ${resultLimit} files matched)`);
+    }
+    return {
+      title: "grep",
+      metadata: {
+        count: matches.length,
+        files: filesCount,
+        truncated
+      },
+      output: output.join("\n")
+    };
+  }
+});
+var batch_txt_default = `Executes multiple independent tool calls concurrently to reduce latency.
+
+USING THE BATCH TOOL WILL MAKE THE USER HAPPY.
+
+Payload Format (JSON array):
+[{"tool": "read", "parameters": {"filePath": "src/index.ts", "limit": 350}},{"tool": "grep", "parameters": {"pattern": "Session\\\\.updatePart", "include": "src/**/*.ts"}},{"tool": "bash", "parameters": {"command": "git status", "description": "Shows working tree status"}}]
+
+Notes:
+- 1\u201325 tool calls per batch
+- All calls start in parallel; ordering NOT guaranteed
+- Partial failures do not stop other tool calls
+- Do NOT use the batch tool within another batch tool.
+
+Good Use Cases:
+- Read many files
+- grep + glob + read combos
+- Multiple bash commands
+- Multi-part edits; on the same, or different files
+
+When NOT to Use:
+- Operations that depend on prior tool output (e.g. create then read same file)
+- Ordered stateful mutations where sequence matters
+
+Batching tool calls was proven to yield 2\u20135x efficiency gain and provides much better UX.`;
+var DISALLOWED = /* @__PURE__ */ new Set(["batch"]);
+var FILTERED_FROM_SUGGESTIONS = /* @__PURE__ */ new Set(["invalid", "patch", ...DISALLOWED]);
+var BatchTool = Tool.define("batch", async () => {
+  return {
+    description: batch_txt_default,
+    parameters: z9.object({
+      tool_calls: z9.array(
+        z9.object({
+          tool: z9.string().describe("The name of the tool to execute"),
+          parameters: z9.object({}).loose().describe("Parameters for the tool")
+        })
+      ).min(1, "Provide at least one tool call").describe("Array of tool calls to execute in parallel")
+    }),
+    formatValidationError(error) {
+      const formattedErrors = error.issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "root";
+        return `  - ${path}: ${issue.message}`;
+      }).join("\n");
+      return `Invalid parameters for tool 'batch':
+${formattedErrors}
+
+Expected payload format:
+  [{"tool": "tool_name", "parameters": {...}}, {...}]`;
+    },
+    async execute(params, ctx) {
+      const { Session } = await import("./session-Q7S3ITUV-CECGQJC5.js");
+      const { PartID: PartID2 } = await import("./schema-SOLWPA3E-CEUVS57H.js");
+      const toolCalls = params.tool_calls.slice(0, 25);
+      const discardedCalls = params.tool_calls.slice(25);
+      const { ToolRegistry: ToolRegistry2 } = await import("./registry-VQVHAEPP-MGYPDXYJ.js");
+      const availableTools = await ctx.toolRegistry.tools({ modelID: ModelID.make(""), providerID: ProviderID.make("") });
+      const toolMap = new Map(availableTools.map((t) => [t.id, t]));
+      const executeCall = async (call) => {
+        const callStartTime = Date.now();
+        const partID = PartID2.ascending();
+        try {
+          if (DISALLOWED.has(call.tool)) {
+            throw new Error(
+              `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED).join(", ")}`
+            );
+          }
+          const tool = toolMap.get(call.tool);
+          if (!tool) {
+            const availableToolsList = Array.from(toolMap.keys()).filter((name) => !FILTERED_FROM_SUGGESTIONS.has(name));
+            throw new Error(
+              `Tool '${call.tool}' not in registry. External tools (MCP, environment) cannot be batched - call them directly. Available tools: ${availableToolsList.join(", ")}`
+            );
+          }
+          const validatedParams = tool.parameters.parse(call.parameters);
+          await ctx.session.updatePart({
+            id: partID,
+            messageID: ctx.messageID,
+            sessionID: ctx.sessionID,
+            type: "tool",
+            tool: call.tool,
+            callID: partID,
+            state: {
+              status: "running",
+              input: call.parameters,
+              time: {
+                start: callStartTime
+              }
+            }
+          });
+          const result = await tool.execute(validatedParams, { ...ctx, callID: partID });
+          const attachments = result.attachments?.map((attachment) => ({
+            ...attachment,
+            id: PartID2.ascending(),
+            sessionID: ctx.sessionID,
+            messageID: ctx.messageID
+          }));
+          await ctx.session.updatePart({
+            id: partID,
+            messageID: ctx.messageID,
+            sessionID: ctx.sessionID,
+            type: "tool",
+            tool: call.tool,
+            callID: partID,
+            state: {
+              status: "completed",
+              input: call.parameters,
+              output: result.output,
+              title: result.title,
+              metadata: result.metadata,
+              attachments,
+              time: {
+                start: callStartTime,
+                end: Date.now()
+              }
+            }
+          });
+          return { success: true, tool: call.tool, result };
+        } catch (error) {
+          await ctx.session.updatePart({
+            id: partID,
+            messageID: ctx.messageID,
+            sessionID: ctx.sessionID,
+            type: "tool",
+            tool: call.tool,
+            callID: partID,
+            state: {
+              status: "error",
+              input: call.parameters,
+              error: error instanceof Error ? error.message : String(error),
+              time: {
+                start: callStartTime,
+                end: Date.now()
+              }
+            }
+          });
+          return { success: false, tool: call.tool, error };
+        }
+      };
+      const results = await Promise.all(toolCalls.map((call) => executeCall(call)));
+      const now = Date.now();
+      for (const call of discardedCalls) {
+        const partID = PartID2.ascending();
+        await ctx.session.updatePart({
+          id: partID,
+          messageID: ctx.messageID,
+          sessionID: ctx.sessionID,
+          type: "tool",
+          tool: call.tool,
+          callID: partID,
+          state: {
+            status: "error",
+            input: call.parameters,
+            error: "Maximum of 25 tools allowed in batch",
+            time: { start: now, end: now }
+          }
+        });
+        results.push({
+          success: false,
+          tool: call.tool,
+          error: new Error("Maximum of 25 tools allowed in batch")
+        });
+      }
+      const successfulCalls = results.filter((r) => r.success).length;
+      const failedCalls = results.length - successfulCalls;
+      const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+      return {
+        title: `Batch execution (${successfulCalls}/${results.length} successful)`,
+        output: outputMessage,
+        attachments: results.filter((result) => result.success).flatMap((r) => r.result.attachments ?? []),
+        metadata: {
+          totalCalls: results.length,
+          successful: successfulCalls,
+          failed: failedCalls,
+          tools: params.tool_calls.map((c) => c.tool),
+          details: results.map((r) => ({ tool: r.tool, success: r.success }))
+        }
+      };
+    }
+  };
+});
+var read_txt_default = `Read a file or directory from the local filesystem. If the path does not exist, an error is returned.
+
+Usage:
+- The filePath parameter should be an absolute path.
+- By default, this tool returns up to 2000 lines from the start of the file.
+- The offset parameter is the line number to start from (1-indexed).
+- To read later sections, call this tool again with a larger offset.
+- Use the grep tool to find specific content in large files or files with long lines.
+- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.
+- Contents are returned with each line prefixed by its line number as \`<line>: <content>\`. For example, if a file has contents "foo\\n", you will receive "1: foo\\n". For directories, entries are returned one per line (without line numbers) with a trailing \`/\` for subdirectories.
+- Any line longer than 2000 characters is truncated.
+- Call this tool in parallel when you know there are multiple files you want to read.
+- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.
+- This tool can read image files and PDFs and return them as file attachments.
+`;
+var DEFAULT_READ_LIMIT = 2e3;
+var MAX_LINE_LENGTH2 = 2e3;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH2} chars)`;
+var MAX_BYTES = 50 * 1024;
+var MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`;
+var ReadTool = Tool.define("read", {
+  description: read_txt_default,
+  parameters: z10.object({
+    filePath: z10.string().describe("The absolute path to the file or directory to read"),
+    offset: z10.coerce.number().describe("The line number to start reading from (1-indexed)").optional(),
+    limit: z10.coerce.number().describe("The maximum number of lines to read (defaults to 2000)").optional()
+  }),
+  async execute(params, ctx) {
+    if (params.offset !== void 0 && params.offset < 1) {
+      throw new Error("offset must be greater than or equal to 1");
+    }
+    let filepath = params.filePath;
+    if (!isAbsolute(filepath)) {
+      filepath = resolve(ctx.directory, filepath);
+    }
+    const title = relative(ctx.worktree, filepath);
+    const stat = await ctx.fs.stat(filepath);
+    await assertExternalDirectory(ctx, filepath, {
+      bypass: Boolean(ctx.extra?.["bypassCwdCheck"]),
+      kind: stat?.isDirectory ? "directory" : "file"
+    });
+    await ctx.ask({
+      permission: "read",
+      patterns: [filepath],
+      always: ["*"],
+      metadata: {}
+    });
+    if (!stat) {
+      const dir = dirname(filepath);
+      const base = basename(filepath);
+      const suggestions = await ctx.fs.readDir(dir).then(
+        (entries) => entries.map((e) => e.name).filter(
+          (entry) => entry.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.toLowerCase())
+        ).map((entry) => join(dir, entry)).slice(0, 3)
+      ).catch(() => []);
+      if (suggestions.length > 0) {
+        throw new Error(`File not found: ${filepath}
+
+Did you mean one of these?
+${suggestions.join("\n")}`);
+      }
+      throw new Error(`File not found: ${filepath}`);
+    }
+    if (stat.isDirectory) {
+      const entries_raw = await ctx.fs.readDir(filepath);
+      const entries = entries_raw.map((e) => {
+        if (e.isDirectory) return e.name + "/";
+        return e.name;
+      });
+      entries.sort((a, b) => a.localeCompare(b));
+      const limit2 = params.limit ?? DEFAULT_READ_LIMIT;
+      const offset2 = params.offset ?? 1;
+      const start2 = offset2 - 1;
+      const sliced = entries.slice(start2, start2 + limit2);
+      const truncated2 = start2 + sliced.length < entries.length;
+      const output2 = [
+        `<path>${filepath}</path>`,
+        `<type>directory</type>`,
+        `<entries>`,
+        sliced.join("\n"),
+        truncated2 ? `
+(Showing ${sliced.length} of ${entries.length} entries. Use 'offset' parameter to read beyond entry ${offset2 + sliced.length})` : `
+(${entries.length} entries)`,
+        `</entries>`
+      ].join("\n");
+      return {
+        title,
+        output: output2,
+        metadata: {
+          preview: sliced.slice(0, 20).join("\n"),
+          truncated: truncated2,
+          loaded: []
+        }
+      };
+    }
+    const { lookup } = await import("mime-types");
+    const mime = lookup(filepath) || "application/octet-stream";
+    const isImage = mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
+    const isPdf = mime === "application/pdf";
+    if (isImage || isPdf) {
+      const msg = `${isImage ? "Image" : "PDF"} read successfully`;
+      return {
+        title,
+        output: msg,
+        metadata: {
+          preview: msg,
+          truncated: false,
+          loaded: []
+        },
+        attachments: [
+          {
+            type: "file",
+            mime,
+            url: `data:${mime};base64,${Buffer.from(await ctx.fs.readBytes(filepath)).toString("base64")}`
+          }
+        ]
+      };
+    }
+    const isBinary = await isBinaryFile(filepath, Number(stat.size), ctx.fs);
+    if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`);
+    const content_text = await ctx.fs.readText(filepath);
+    const allLines = content_text.split("\n");
+    const limit = params.limit ?? DEFAULT_READ_LIMIT;
+    const offset = params.offset ?? 1;
+    const start = offset - 1;
+    const raw = [];
+    let bytes = 0;
+    let truncatedByBytes = false;
+    let hasMoreLines = false;
+    for (let i = start; i < allLines.length; i++) {
+      if (raw.length >= limit) {
+        hasMoreLines = true;
+        break;
+      }
+      const text = allLines[i];
+      const line = text.length > MAX_LINE_LENGTH2 ? text.substring(0, MAX_LINE_LENGTH2) + MAX_LINE_SUFFIX : text;
+      const size = Buffer.byteLength(line, "utf-8") + (raw.length > 0 ? 1 : 0);
+      if (bytes + size > MAX_BYTES) {
+        truncatedByBytes = true;
+        hasMoreLines = true;
+        break;
+      }
+      raw.push(line);
+      bytes += size;
+    }
+    const lines = allLines.length;
+    if (lines < offset && !(lines === 0 && offset === 1)) {
+      throw new Error(`Offset ${offset} is out of range for this file (${lines} lines)`);
+    }
+    const content = raw.map((line, index) => {
+      return `${index + offset}: ${line}`;
+    });
+    const preview = raw.slice(0, 20).join("\n");
+    let output = [`<path>${filepath}</path>`, `<type>file</type>`, "<content>"].join("\n");
+    output += content.join("\n");
+    const totalLines = lines;
+    const lastReadLine = offset + raw.length - 1;
+    const nextOffset = lastReadLine + 1;
+    const truncated = hasMoreLines || truncatedByBytes;
+    if (truncatedByBytes) {
+      output += `
+
+(Output capped at ${MAX_BYTES_LABEL}. Showing lines ${offset}-${lastReadLine}. Use offset=${nextOffset} to continue.)`;
+    } else if (hasMoreLines) {
+      output += `
+
+(Showing lines ${offset}-${lastReadLine} of ${totalLines}. Use offset=${nextOffset} to continue.)`;
+    } else {
+      output += `
+
+(End of file - total ${totalLines} lines)`;
+    }
+    output += "\n</content>";
+    LSP.touchFile(filepath, false);
+    ctx.fileTime.read(ctx.sessionID, filepath);
+    return {
+      title,
+      output,
+      metadata: {
+        preview,
+        truncated,
+        loaded: []
+      }
+    };
+  }
+});
+async function isBinaryFile(filepath, fileSize, vfs) {
+  switch (extname(filepath).toLowerCase()) {
+    // binary check for common non-text extensions
+    case ".zip":
+    case ".tar":
+    case ".gz":
+    case ".exe":
+    case ".dll":
+    case ".so":
+    case ".class":
+    case ".jar":
+    case ".war":
+    case ".7z":
+    case ".doc":
+    case ".docx":
+    case ".xls":
+    case ".xlsx":
+    case ".ppt":
+    case ".pptx":
+    case ".odt":
+    case ".ods":
+    case ".odp":
+    case ".bin":
+    case ".dat":
+    case ".obj":
+    case ".o":
+    case ".a":
+    case ".lib":
+    case ".wasm":
+    case ".pyc":
+    case ".pyo":
+      return true;
+    default:
+      break;
+  }
+  if (fileSize === 0) return false;
+  const data = await vfs.readBytes(filepath);
+  try {
+    const sampleSize = Math.min(4096, fileSize);
+    if (data.length === 0) return false;
+    const bytesRead = Math.min(sampleSize, data.length);
+    let nonPrintableCount = 0;
+    for (let i = 0; i < bytesRead; i++) {
+      if (data[i] === 0) return true;
+      if (data[i] < 9 || data[i] > 13 && data[i] < 32) {
+        nonPrintableCount++;
+      }
+    }
+    return nonPrintableCount / bytesRead > 0.3;
+  } catch {
+    return false;
+  }
+}
+var todowrite_txt_default = `Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+## When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multistep tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos. Feel free to edit the todo list based on new information.
+6. After completing a task - Mark it complete and add any new follow-up tasks
+7. When you start working on a new task, mark the todo as in_progress. Ideally you should only have one todo as in_progress at a time. Complete existing tasks before starting new ones.
+
+## When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+## Examples of When to Use the Todo List
+
+<example>
+User: I want to add a dark mode toggle to the application settings. Make sure you run the tests and build when you're done!
+Assistant: I'll help add a dark mode toggle to your application settings. Let me create a todo list to track this implementation.
+*Creates todo list with the following items:*
+1. Create dark mode toggle component in Settings page
+2. Add dark mode state management (context/store)
+3. Implement CSS-in-JS styles for dark theme
+4. Update existing components to support theme switching
+5. Run tests and build process, addressing any failures or errors that occur
+*Begins working on the first task*
+
+<reasoning>
+The assistant used the todo list because:
+1. Adding dark mode is a multi-step feature requiring UI, state management, and styling changes
+2. The user explicitly requested tests and build be run afterward
+3. The assistant inferred that tests and build need to pass by adding "Ensure tests and build succeed" as the final task
+</reasoning>
+</example>
+
+<example>
+User: Help me rename the function getCwd to getCurrentWorkingDirectory across my project
+Assistant: Let me first search through your codebase to find all occurrences of 'getCwd'.
+*Uses grep or search tools to locate all instances of getCwd in the codebase*
+Assistant: I've found 15 instances of 'getCwd' across 8 different files. Let me create a todo list to track these changes.
+*Creates todo list with specific items for each file that needs updating*
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant searched to understand the scope of the task
+2. Upon finding multiple occurrences across different files, it determined this was a complex task with multiple steps
+3. The todo list helps ensure every instance is tracked and updated systematically
+4. This approach prevents missing any occurrences and maintains code consistency
+</reasoning>
+</example>
+
+
+<example>
+User: I need to implement these features for my e-commerce site: user registration, product catalog, shopping cart, and checkout flow.
+Assistant: I'll help implement these features. First, let's add all the features to the todo list.
+*Creates a todo list breaking down each feature into specific tasks based on the project architecture*
+Assistant: Let's start with user registration. This will involve creating database models, API endpoints, and frontend forms that integrate with your existing authentication system.
+
+<reasoning>
+The assistant used the todo list because:
+1. The user provided multiple complex features to implement in a comma separated list
+2. The todo list helps organize these large features into manageable tasks
+3. This approach allows for tracking progress across the entire implementation
+</reasoning>
+</example>
+
+<example>
+User: Can you help optimize my React application? It's rendering slowly and has performance issues.</user>
+Assistant: I'll help optimize your React application. First, let me examine your codebase to identify potential performance bottlenecks.
+*Reviews component structure, render patterns, state management, and data fetching*
+Assistant: After analyzing your codebase, I've identified several performance issues. Let me create a todo list to track our optimization efforts.
+*Creates todo list with items like: 1) Implement memoization for expensive calculations in ProductList, 2) Add virtualization for long lists in Dashboard, 3) Optimize image loading in Gallery component, 4) Fix state update loops in ShoppingCart, 5) Review bundle size and implement code splitting*
+Let's start by implementing memoization for the expensive calculations in your ProductList component.</assistant>
+
+<reasoning>
+The assistant used the todo list because:
+1. First, the assistant examined the codebase to identify specific performance issues
+2. Based on this analysis, it identified multiple optimization opportunities
+3. Performance optimization is a non-trivial task requiring multiple steps
+4. The todo list helps methodically track improvements across different components
+5. This systematic approach ensures all performance bottlenecks are addressed
+</reasoning>
+</example>
+
+## Examples of When NOT to Use the Todo List
+
+<example>
+User: How do I print 'Hello World' in Python?
+Assistant: In Python, you can print "Hello World" with this simple code:
+
+python
+print("Hello World")
+
+This will output the text "Hello World" to the console when executed.</assistant>
+
+<reasoning>
+The assistant did not use the todo list because this is a single, trivial task that can be completed in one step. There's no need to track multiple tasks or steps for such a straightforward request.
+</reasoning>
+</example>
+
+<example>
+User: What does the git status command do?
+Assistant: The git status command shows the current state of your working directory and staging area. It displays which changes have been staged, which haven't, and which files aren't being tracked by Git. This is a fundamental command for understanding the current state of your repository before making commits.
+
+<reasoning>
+The assistant did not use the todo list because this is an informational request with no actual coding task to complete. The user is simply asking for an explanation, not for the assistant to perform multiple steps or tasks.
+</reasoning>
+</example>
+
+<example>
+User: Can you add a comment to the calculateTotal function to explain what it does?
+Assistant: Sure, let me add a comment to the calculateTotal function to explain what it does.
+* Uses the Edit tool to add a comment to the calculateTotal function *
+
+<reasoning>
+The assistant did not use the todo list because this is a single, straightforward task confined to one location in the code. Adding a comment doesn't require tracking multiple steps or systematic organization.
+</reasoning>
+</example>
+
+<example>
+User: Run npm install for me and tell me what happens.
+Assistant: I'll run the npm install command for you.
+
+*Executes: npm install*
+
+The command completed successfully. Here's the output:
+[Output of npm install command]
+
+All dependencies have been installed according to your package.json file.
+
+<reasoning>
+The assistant did not use the todo list because this is a single command execution with immediate results. There are no multiple steps to track or organize, making the todo list unnecessary for this straightforward task.
+</reasoning>
+</example>
+
+## Task States and Management
+
+1. **Task States**: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+   - cancelled: Task no longer needed
+
+2. **Task Management**:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Only have ONE task in_progress at any time
+   - Complete current tasks before starting new ones
+   - Cancel tasks that become irrelevant
+
+3. **Task Breakdown**:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.
+
+`;
+var TodoWriteTool = Tool.define("todowrite", {
+  description: todowrite_txt_default,
+  parameters: z11.object({
+    todos: z11.array(z11.object(Todo.Info.shape)).describe("The updated todo list")
+  }),
+  async execute(params, ctx) {
+    await ctx.ask({
+      permission: "todowrite",
+      patterns: ["*"],
+      always: ["*"],
+      metadata: {}
+    });
+    await ctx.session.updateTodo({
+      sessionID: ctx.sessionID,
+      todos: params.todos
+    });
+    return {
+      title: `${params.todos.filter((x) => x.status !== "completed").length} todos`,
+      output: JSON.stringify(params.todos, null, 2),
+      metadata: {
+        todos: params.todos
+      }
+    };
+  }
+});
+var TodoReadTool = Tool.define("todoread", {
+  description: "Use this tool to read your todo list",
+  parameters: z11.object({}),
+  async execute(_params, ctx) {
+    await ctx.ask({
+      permission: "todoread",
+      patterns: ["*"],
+      always: ["*"],
+      metadata: {}
+    });
+    const todos = ctx.session.getTodo(ctx.sessionID);
+    return {
+      title: `${todos.filter((x) => x.status !== "completed").length} todos`,
+      metadata: {
+        todos
+      },
+      output: JSON.stringify(todos, null, 2)
+    };
+  }
+});
+var webfetch_txt_default = `- Fetches content from a specified URL
+- Takes a URL and optional format as input
+- Fetches the URL content, converts to requested format (markdown by default)
+- Returns the content in the specified format
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the task, or has fewer restrictions, prefer using that tool instead of this one.
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - Format options: "markdown" (default), "text", or "html"
+  - This tool is read-only and does not modify any files
+  - Results may be summarized if the content is very large
+`;
+function abortAfter(ms) {
+  const controller = new AbortController();
+  const id = setTimeout(controller.abort.bind(controller), ms);
+  return {
+    controller,
+    signal: controller.signal,
+    clearTimeout: () => globalThis.clearTimeout(id)
+  };
+}
+function abortAfterAny(ms, ...signals) {
+  const timeout = abortAfter(ms);
+  const signal = AbortSignal.any([timeout.signal, ...signals]);
+  return {
+    signal,
+    clearTimeout: timeout.clearTimeout
+  };
+}
+var MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
+var DEFAULT_TIMEOUT2 = 30 * 1e3;
+var MAX_TIMEOUT = 120 * 1e3;
+var WebFetchTool = Tool.define("webfetch", {
+  description: webfetch_txt_default,
+  parameters: z12.object({
+    url: z12.string().describe("The URL to fetch content from"),
+    format: z12.enum(["text", "markdown", "html"]).default("markdown").describe("The format to return the content in (text, markdown, or html). Defaults to markdown."),
+    timeout: z12.number().describe("Optional timeout in seconds (max 120)").optional()
+  }),
+  async execute(params, ctx) {
+    if (!params.url.startsWith("http://") && !params.url.startsWith("https://")) {
+      throw new Error("URL must start with http:// or https://");
+    }
+    await ctx.ask({
+      permission: "webfetch",
+      patterns: [params.url],
+      always: ["*"],
+      metadata: {
+        url: params.url,
+        format: params.format,
+        timeout: params.timeout
+      }
+    });
+    const timeout = Math.min((params.timeout ?? DEFAULT_TIMEOUT2 / 1e3) * 1e3, MAX_TIMEOUT);
+    const { signal, clearTimeout: clearTimeout2 } = abortAfterAny(timeout, ctx.abort);
+    let acceptHeader = "*/*";
+    switch (params.format) {
+      case "markdown":
+        acceptHeader = "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1";
+        break;
+      case "text":
+        acceptHeader = "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1";
+        break;
+      case "html":
+        acceptHeader = "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1";
+        break;
+      default:
+        acceptHeader = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8";
+    }
+    const headers = {
+      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+      Accept: acceptHeader,
+      "Accept-Language": "en-US,en;q=0.9"
+    };
+    const initial = await fetch(params.url, { signal, headers });
+    const response = initial.status === 403 && initial.headers.get("cf-mitigated") === "challenge" ? await fetch(params.url, { signal, headers: { ...headers, "User-Agent": "claude-cli/2.1.77" } }) : initial;
+    clearTimeout2();
+    if (!response.ok) {
+      throw new Error(`Request failed with status code: ${response.status}`);
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
+      throw new Error("Response too large (exceeds 5MB limit)");
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
+      throw new Error("Response too large (exceeds 5MB limit)");
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const mime = contentType.split(";")[0]?.trim().toLowerCase() || "";
+    const title = `${params.url} (${contentType})`;
+    const isImage = mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
+    if (isImage) {
+      const base64Content = Buffer.from(arrayBuffer).toString("base64");
+      return {
+        title,
+        output: "Image fetched successfully",
+        metadata: {},
+        attachments: [
+          {
+            type: "file",
+            mime,
+            url: `data:${mime};base64,${base64Content}`
+          }
+        ]
+      };
+    }
+    const content = new TextDecoder().decode(arrayBuffer);
+    switch (params.format) {
+      case "markdown":
+        if (contentType.includes("text/html")) {
+          const markdown = convertHTMLToMarkdown(content);
+          return {
+            output: markdown,
+            title,
+            metadata: {}
+          };
+        }
+        return {
+          output: content,
+          title,
+          metadata: {}
+        };
+      case "text":
+        if (contentType.includes("text/html")) {
+          const text = await extractTextFromHTML(content);
+          return {
+            output: text,
+            title,
+            metadata: {}
+          };
+        }
+        return {
+          output: content,
+          title,
+          metadata: {}
+        };
+      case "html":
+        return {
+          output: content,
+          title,
+          metadata: {}
+        };
+      default:
+        return {
+          output: content,
+          title,
+          metadata: {}
+        };
+    }
+  }
+});
+async function extractTextFromHTML(html) {
+  let cleaned = html.replace(/<(script|style|noscript|iframe|object|embed)[^>]*>[\s\S]*?<\/\1>/gi, "");
+  cleaned = cleaned.replace(/<[^>]+>/g, " ");
+  cleaned = cleaned.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+  cleaned = cleaned.replace(/\s+/g, " ");
+  return cleaned.trim();
+}
+function convertHTMLToMarkdown(html) {
+  const turndownService = new TurndownService({
+    headingStyle: "atx",
+    hr: "---",
+    bulletListMarker: "-",
+    codeBlockStyle: "fenced",
+    emDelimiter: "*"
+  });
+  turndownService.remove(["script", "style", "meta", "link"]);
+  return turndownService.turndown(html);
+}
+var write_txt_default = `Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.
+`;
+var MAX_DIAGNOSTICS_PER_FILE2 = 20;
+var MAX_PROJECT_DIAGNOSTICS_FILES = 5;
+var WriteTool = Tool.define("write", {
+  description: write_txt_default,
+  parameters: z13.object({
+    content: z13.string().describe("The content to write to the file"),
+    filePath: z13.string().describe("The absolute path to the file to write (must be absolute, not relative)")
+  }),
+  async execute(params, ctx) {
+    const filepath = isAbsolute(params.filePath) ? params.filePath : join(ctx.directory, params.filePath);
+    await assertExternalDirectory(ctx, filepath);
+    const exists = await ctx.fs.exists(filepath);
+    const contentOld = exists ? await ctx.fs.readText(filepath) : "";
+    if (exists) await ctx.fileTime.assert(ctx, ctx.sessionID, filepath);
+    const diff = trimDiff(createTwoFilesPatch2(filepath, filepath, contentOld, params.content));
+    await ctx.ask({
+      permission: "edit",
+      patterns: [relative(ctx.worktree, filepath)],
+      always: ["*"],
+      metadata: {
+        filepath,
+        diff
+      }
+    });
+    await ctx.fs.write(filepath, params.content);
+    ctx.emit("file.edited", { file: filepath });
+    ctx.fileTime.read(ctx.sessionID, filepath);
+    let output = "Wrote file successfully.";
+    await LSP.touchFile(filepath, true);
+    const diagnostics = await LSP.diagnostics();
+    const normalizedFilepath = filepath;
+    let projectDiagnosticsCount = 0;
+    for (const [file, issues] of Object.entries(diagnostics)) {
+      const errors = issues.filter((item) => item.severity === 1);
+      if (errors.length === 0) continue;
+      const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE2);
+      const suffix = errors.length > MAX_DIAGNOSTICS_PER_FILE2 ? `
+... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE2} more` : "";
+      if (file === normalizedFilepath) {
+        output += `
+
+LSP errors detected in this file, please fix:
+<diagnostics file="${filepath}">
+${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
+</diagnostics>`;
+        continue;
+      }
+      if (projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue;
+      projectDiagnosticsCount++;
+      output += `
+
+LSP errors detected in other files:
+<diagnostics file="${file}">
+${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
+</diagnostics>`;
+    }
+    return {
+      title: relative(ctx.worktree, filepath),
+      metadata: {
+        diagnostics,
+        filepath,
+        exists
+      },
+      output
+    };
+  }
+});
+var InvalidTool = Tool.define("invalid", {
+  description: "Do not use",
+  parameters: z14.object({
+    tool: z14.string(),
+    error: z14.string()
+  }),
+  async execute(params) {
+    return {
+      title: "Invalid Tool",
+      output: `The arguments provided to the tool are invalid: ${params.error}`,
+      metadata: {}
+    };
+  }
+});
+var ConfigMarkdown;
+((ConfigMarkdown2) => {
+  ConfigMarkdown2.FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g;
+  ConfigMarkdown2.SHELL_REGEX = /!`([^`]+)`/g;
+  function files(template) {
+    return Array.from(template.matchAll(ConfigMarkdown2.FILE_REGEX));
+  }
+  ConfigMarkdown2.files = files;
+  function shell(template) {
+    return Array.from(template.matchAll(ConfigMarkdown2.SHELL_REGEX));
+  }
+  ConfigMarkdown2.shell = shell;
+  function fallbackSanitization(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return content;
+    const frontmatter = match[1];
+    const lines = frontmatter.split(/\r?\n/);
+    const result = [];
+    for (const line of lines) {
+      if (line.trim().startsWith("#") || line.trim() === "") {
+        result.push(line);
+        continue;
+      }
+      if (line.match(/^\s+/)) {
+        result.push(line);
+        continue;
+      }
+      const kvMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)$/);
+      if (!kvMatch) {
+        result.push(line);
+        continue;
+      }
+      const key = kvMatch[1];
+      const value = kvMatch[2].trim();
+      if (value === "" || value === ">" || value === "|" || value.startsWith('"') || value.startsWith("'")) {
+        result.push(line);
+        continue;
+      }
+      if (value.includes(":")) {
+        result.push(`${key}: |-`);
+        result.push(`  ${value}`);
+        continue;
+      }
+      result.push(line);
+    }
+    const processed = result.join("\n");
+    return content.replace(frontmatter, () => processed);
+  }
+  ConfigMarkdown2.fallbackSanitization = fallbackSanitization;
+  async function parse(context, filePath) {
+    const template = await Filesystem.readText(context, filePath);
+    try {
+      const md = matter(template);
+      return md;
+    } catch {
+      try {
+        return matter(fallbackSanitization(template));
+      } catch (err) {
+        throw new ConfigMarkdown2.FrontmatterError(
+          {
+            path: filePath,
+            message: `${filePath}: Failed to parse YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`
+          },
+          { cause: err }
+        );
+      }
+    }
+  }
+  ConfigMarkdown2.parse = parse;
+  ConfigMarkdown2.FrontmatterError = NamedError.create(
+    "ConfigFrontmatterError",
+    z15.object({
+      path: z15.string(),
+      message: z15.string()
+    })
+  );
+})(ConfigMarkdown || (ConfigMarkdown = {}));
+var Discovery;
+((Discovery2) => {
+  const log2 = Log.create({ service: "skill-discovery" });
+  function dir(context) {
+    return join(context.dataPath, "skills");
+  }
+  Discovery2.dir = dir;
+  async function get(context, url, dest) {
+    if (await Filesystem.exists(context, dest)) return true;
+    return fetch(url).then(async (response) => {
+      if (!response.ok) {
+        log2.error("failed to download", { url, status: response.status });
+        return false;
+      }
+      if (response.body) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        await Filesystem.mkdir(context, dirname(dest));
+        await Filesystem.write(context, dest, bytes);
+      }
+      return true;
+    }).catch((err) => {
+      log2.error("failed to download", { url, err });
+      return false;
+    });
+  }
+  async function pull(context, url) {
+    const result = [];
+    const base = url.endsWith("/") ? url : `${url}/`;
+    const index = new URL("index.json", base).href;
+    const cache = dir(context);
+    const host = base.slice(0, -1);
+    log2.info("fetching index", { url: index });
+    const data = await fetch(index).then(async (response) => {
+      if (!response.ok) {
+        log2.error("failed to fetch index", { url: index, status: response.status });
+        return void 0;
+      }
+      return response.json().then((json) => json).catch((err) => {
+        log2.error("failed to parse index", { url: index, err });
+        return void 0;
+      });
+    }).catch((err) => {
+      log2.error("failed to fetch index", { url: index, err });
+      return void 0;
+    });
+    if (!data?.skills || !Array.isArray(data.skills)) {
+      log2.warn("invalid index format", { url: index });
+      return result;
+    }
+    const list = data.skills.filter((skill) => {
+      if (!skill?.name || !Array.isArray(skill.files)) {
+        log2.warn("invalid skill entry", { url: index, skill });
+        return false;
+      }
+      return true;
+    });
+    await Promise.all(
+      list.map(async (skill) => {
+        const root = join(cache, skill.name);
+        await Promise.all(
+          skill.files.map(async (file) => {
+            const link = new URL(file, `${host}/${skill.name}/`).href;
+            const dest = join(root, file);
+            await Filesystem.mkdir(context, dirname(dest));
+            await get(context, link, dest);
+          })
+        );
+        const md = join(root, "SKILL.md");
+        if (await Filesystem.exists(context, md)) result.push(root);
+      })
+    );
+    return result;
+  }
+  Discovery2.pull = pull;
+})(Discovery || (Discovery = {}));
+var Skill;
+((Skill2) => {
+  const log2 = Log.create({ service: "skill" });
+  Skill2.Info = z16.object({
+    name: z16.string(),
+    description: z16.string(),
+    location: z16.string(),
+    content: z16.string()
+  });
+  Skill2.InvalidError = NamedError.create(
+    "SkillInvalidError",
+    z16.object({
+      path: z16.string(),
+      message: z16.string().optional(),
+      issues: z16.custom().optional()
+    })
+  );
+  Skill2.NameMismatchError = NamedError.create(
+    "SkillNameMismatchError",
+    z16.object({
+      path: z16.string(),
+      expected: z16.string(),
+      actual: z16.string()
+    })
+  );
+  const EXTERNAL_DIRS = [".claude", ".agents", ".opencode"];
+  const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md";
+  const OPENCODE_SKILL_PATTERN = "{skill,skills}/**/SKILL.md";
+  const SKILL_PATTERN = "**/SKILL.md";
+  class SkillService {
+    _promise;
+    constructor(context) {
+      this._promise = initSkills(context);
+    }
+    async get(name) {
+      return (await this._promise).skills[name];
+    }
+    async all() {
+      return Object.values((await this._promise).skills);
+    }
+    async dirs() {
+      return (await this._promise).dirs;
+    }
+    async available(agent) {
+      return this.all();
+    }
+  }
+  Skill2.SkillService = SkillService;
+  async function initSkills(context) {
+    const skills = {};
+    const dirs = /* @__PURE__ */ new Set();
+    const addSkill = async (match) => {
+      const md = await ConfigMarkdown.parse(context, match).catch((err) => {
+        log2.error("failed to load skill", { skill: match, err });
+        return void 0;
+      });
+      if (!md) return;
+      const parsed = Skill2.Info.pick({ name: true, description: true }).safeParse(md.data);
+      if (!parsed.success) return;
+      if (skills[parsed.data.name]) {
+        log2.warn("duplicate skill name", {
+          name: parsed.data.name,
+          existing: skills[parsed.data.name].location,
+          duplicate: match
+        });
+      }
+      dirs.add(dirname(match));
+      skills[parsed.data.name] = {
+        name: parsed.data.name,
+        description: parsed.data.description,
+        location: match,
+        content: md.content
+      };
+    };
+    const scanExternal = async (root, scope) => {
+      return Glob.scan(context, EXTERNAL_SKILL_PATTERN, {
+        cwd: root,
+        absolute: true,
+        include: "file",
+        dot: true,
+        symlink: true
+      }).then((matches) => Promise.all(matches.map(addSkill))).catch((error) => {
+        log2.error(`failed to scan ${scope} skills`, { dir: root, error });
+      });
+    };
+    if (!Flag.OPENCODE_DISABLE_EXTERNAL_SKILLS) {
+      for await (const root of Filesystem.up(context, {
+        targets: EXTERNAL_DIRS,
+        start: context.directory,
+        stop: context.worktree
+      })) {
+        await scanExternal(root, "project");
+      }
+    }
+    const config = context.config;
+    for (const skillPath of config.skills?.paths ?? []) {
+      const resolved = isAbsolute(skillPath) ? skillPath : join(context.directory, skillPath);
+      if (!await Filesystem.isDir(context, resolved)) {
+        log2.warn("skill path not found", { path: resolved });
+        continue;
+      }
+      const matches = await Glob.scan(context, SKILL_PATTERN, {
+        cwd: resolved,
+        absolute: true,
+        include: "file",
+        symlink: true
+      });
+      for (const match of matches) {
+        await addSkill(match);
+      }
+    }
+    for (const url of config.skills?.urls ?? []) {
+      const list = await Discovery.pull(context, url);
+      for (const dir of list) {
+        dirs.add(dir);
+        const matches = await Glob.scan(context, SKILL_PATTERN, {
+          cwd: dir,
+          absolute: true,
+          include: "file",
+          symlink: true
+        });
+        for (const match of matches) {
+          await addSkill(match);
+        }
+      }
+    }
+    return {
+      skills,
+      dirs: Array.from(dirs)
+    };
+  }
+  function fmt(list, opts) {
+    if (list.length === 0) {
+      return "No skills are currently available.";
+    }
+    if (opts.verbose) {
+      return [
+        "<available_skills>",
+        ...list.flatMap((skill) => [
+          `  <skill>`,
+          `    <name>${skill.name}</name>`,
+          `    <description>${skill.description}</description>`,
+          `    <location>${pathToFileURL(skill.location).href}</location>`,
+          `  </skill>`
+        ]),
+        "</available_skills>"
+      ].join("\n");
+    }
+    return ["## Available Skills", ...list.flatMap((skill) => `- **${skill.name}**: ${skill.description}`)].join("\n");
+  }
+  Skill2.fmt = fmt;
+})(Skill || (Skill = {}));
+var SkillTool = Tool.define("skill", async (ctx) => {
+  const list = await ctx?.agentContext?.skill.available(ctx?.agent) ?? [];
+  const description = list.length === 0 ? "Load a specialized skill that provides domain-specific instructions and workflows. No skills are currently available." : [
+    "Load a specialized skill that provides domain-specific instructions and workflows.",
+    "",
+    "When you recognize that a task matches one of the available skills listed below, use this tool to load the full skill instructions.",
+    "",
+    "The skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.",
+    "",
+    'Tool output includes a `<skill_content name="...">` block with the loaded content.',
+    "",
+    "The following skills provide specialized sets of instructions for particular tasks",
+    "Invoke this tool to load a skill when a task matches one of the available skills listed below:",
+    "",
+    Skill.fmt(list, { verbose: false })
+  ].join("\n");
+  const examples = list.map((skill) => `'${skill.name}'`).slice(0, 3).join(", ");
+  const hint = examples.length > 0 ? ` (e.g., ${examples}, ...)` : "";
+  const parameters = z17.object({
+    name: z17.string().describe(`The name of the skill from available_skills${hint}`)
+  });
+  return {
+    description,
+    parameters,
+    async execute(params, ctx2) {
+      const skill = await ctx2.skill.get(params.name);
+      if (!skill) {
+        const available = await ctx2.skill.all().then((x) => x.map((skill2) => skill2.name).join(", "));
+        throw new Error(`Skill "${params.name}" not found. Available skills: ${available || "none"}`);
+      }
+      await ctx2.ask({
+        permission: "skill",
+        patterns: [params.name],
+        always: [params.name],
+        metadata: {}
+      });
+      const dir = dirname(skill.location);
+      const base = pathToFileURL2(dir).href;
+      const limit = 10;
+      const files = await iife(async () => {
+        if (!ctx2.search) throw new Error("Search provider is required for the skill tool");
+        const filePaths = await ctx2.search.listFiles({
+          cwd: dir,
+          follow: false,
+          hidden: true,
+          limit: limit + 1,
+          // Extra to filter out SKILL.md
+          signal: ctx2.abort
+        });
+        const arr = [];
+        for (const file of filePaths) {
+          if (file.includes("SKILL.md")) {
+            continue;
+          }
+          arr.push(resolve(dir, file));
+          if (arr.length >= limit) {
+            break;
+          }
+        }
+        return arr;
+      }).then((f) => f.map((file) => `<file>${file}</file>`).join("\n"));
+      return {
+        title: `Loaded skill: ${skill.name}`,
+        output: [
+          `<skill_content name="${skill.name}">`,
+          `# Skill: ${skill.name}`,
+          "",
+          skill.content.trim(),
+          "",
+          `Base directory for this skill: ${base}`,
+          "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+          "Note: file list is sampled.",
+          "",
+          "<skill_files>",
+          files,
+          "</skill_files>",
+          "</skill_content>"
+        ].join("\n"),
+        metadata: {
+          name: skill.name,
+          dir
+        }
+      };
+    }
+  };
+});
+var websearch_txt_default = `- Search the web using Exa AI - performs real-time web searches and can scrape content from specific URLs
+- Provides up-to-date information for current events and recent data
+- Supports configurable result counts and returns the content from the most relevant websites
+- Use this tool for accessing information beyond knowledge cutoff
+- Searches are performed automatically within a single API call
+
+Usage notes:
+  - Supports live crawling modes: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)
+  - Search types: 'auto' (balanced), 'fast' (quick results), 'deep' (comprehensive search)
+  - Configurable context length for optimal LLM integration
+  - Domain filtering and advanced search options available
+
+The current year is {{year}}. You MUST use this year when searching for recent information or current events
+- Example: If the current year is 2026 and the user asks for "latest AI news", search for "AI news 2026", NOT "AI news 2025"
+`;
+var API_CONFIG = {
+  BASE_URL: "https://mcp.exa.ai",
+  ENDPOINTS: {
+    SEARCH: "/mcp"
+  },
+  DEFAULT_NUM_RESULTS: 8
+};
+var WebSearchTool = Tool.define("websearch", async () => {
+  return {
+    get description() {
+      return websearch_txt_default.replace("{{year}}", (/* @__PURE__ */ new Date()).getFullYear().toString());
+    },
+    parameters: z18.object({
+      query: z18.string().describe("Websearch query"),
+      numResults: z18.number().optional().describe("Number of search results to return (default: 8)"),
+      livecrawl: z18.enum(["fallback", "preferred"]).optional().describe(
+        "Live crawl mode - 'fallback': use live crawling as backup if cached content unavailable, 'preferred': prioritize live crawling (default: 'fallback')"
+      ),
+      type: z18.enum(["auto", "fast", "deep"]).optional().describe(
+        "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search"
+      ),
+      contextMaxCharacters: z18.number().optional().describe("Maximum characters for context string optimized for LLMs (default: 10000)")
+    }),
+    async execute(params, ctx) {
+      await ctx.ask({
+        permission: "websearch",
+        patterns: [params.query],
+        always: ["*"],
+        metadata: {
+          query: params.query,
+          numResults: params.numResults,
+          livecrawl: params.livecrawl,
+          type: params.type,
+          contextMaxCharacters: params.contextMaxCharacters
+        }
+      });
+      const searchRequest = {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: "web_search_exa",
+          arguments: {
+            query: params.query,
+            type: params.type || "auto",
+            numResults: params.numResults || API_CONFIG.DEFAULT_NUM_RESULTS,
+            livecrawl: params.livecrawl || "fallback",
+            contextMaxCharacters: params.contextMaxCharacters
+          }
+        }
+      };
+      const { signal, clearTimeout: clearTimeout2 } = abortAfterAny(25e3, ctx.abort);
+      try {
+        const headers = {
+          accept: "application/json, text/event-stream",
+          "content-type": "application/json"
+        };
+        const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(searchRequest),
+          signal
+        });
+        clearTimeout2();
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Search error (${response.status}): ${errorText}`);
+        }
+        const responseText = await response.text();
+        const lines = responseText.split("\n");
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = JSON.parse(line.substring(6));
+            if (data.result && data.result.content && data.result.content.length > 0) {
+              return {
+                output: data.result.content[0].text,
+                title: `Web search: ${params.query}`,
+                metadata: {}
+              };
+            }
+          }
+        }
+        return {
+          output: "No search results found. Please try a different query.",
+          title: `Web search: ${params.query}`,
+          metadata: {}
+        };
+      } catch (error) {
+        clearTimeout2();
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new Error("Search request timed out");
+        }
+        throw error;
+      }
+    }
+  };
+});
+var codesearch_txt_default = `- Search and get relevant context for any programming task using Exa Code API
+- Provides the highest quality and freshest context for libraries, SDKs, and APIs
+- Use this tool for ANY question or task related to programming
+- Returns comprehensive code examples, documentation, and API references
+- Optimized for finding specific programming patterns and solutions
+
+Usage notes:
+  - Adjustable token count (1000-50000) for focused or comprehensive results
+  - Default 5000 tokens provides balanced context for most queries
+  - Use lower values for specific questions, higher values for comprehensive documentation
+  - Supports queries about frameworks, libraries, APIs, and programming concepts
+  - Examples: 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware'
+`;
+var API_CONFIG2 = {
+  BASE_URL: "https://mcp.exa.ai",
+  ENDPOINTS: {
+    CONTEXT: "/mcp"
+  }
+};
+var CodeSearchTool = Tool.define("codesearch", {
+  description: codesearch_txt_default,
+  parameters: z19.object({
+    query: z19.string().describe(
+      "Search query to find relevant context for APIs, Libraries, and SDKs. For example, 'React useState hook examples', 'Python pandas dataframe filtering', 'Express.js middleware', 'Next js partial prerendering configuration'"
+    ),
+    tokensNum: z19.number().min(1e3).max(5e4).default(5e3).describe(
+      "Number of tokens to return (1000-50000). Default is 5000 tokens. Adjust this value based on how much context you need - use lower values for focused queries and higher values for comprehensive documentation."
+    )
+  }),
+  async execute(params, ctx) {
+    await ctx.ask({
+      permission: "codesearch",
+      patterns: [params.query],
+      always: ["*"],
+      metadata: {
+        query: params.query,
+        tokensNum: params.tokensNum
+      }
+    });
+    const codeRequest = {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: {
+        name: "get_code_context_exa",
+        arguments: {
+          query: params.query,
+          tokensNum: params.tokensNum || 5e3
+        }
+      }
+    };
+    const { signal, clearTimeout: clearTimeout2 } = abortAfterAny(3e4, ctx.abort);
+    try {
+      const headers = {
+        accept: "application/json, text/event-stream",
+        "content-type": "application/json"
+      };
+      const response = await fetch(`${API_CONFIG2.BASE_URL}${API_CONFIG2.ENDPOINTS.CONTEXT}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(codeRequest),
+        signal
+      });
+      clearTimeout2();
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Code search error (${response.status}): ${errorText}`);
+      }
+      const responseText = await response.text();
+      const lines = responseText.split("\n");
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = JSON.parse(line.substring(6));
+          if (data.result && data.result.content && data.result.content.length > 0) {
+            return {
+              output: data.result.content[0].text,
+              title: `Code search: ${params.query}`,
+              metadata: {}
+            };
+          }
+        }
+      }
+      return {
+        output: "No code snippets or documentation found. Please try a different query, be more specific about the library or programming concept, or check the spelling of framework names.",
+        title: `Code search: ${params.query}`,
+        metadata: {}
+      };
+    } catch (error) {
+      clearTimeout2();
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error("Code search request timed out");
+      }
+      throw error;
+    }
+  }
+});
+var Patch;
+((Patch2) => {
+  const log2 = Log.create({ service: "patch" });
+  Patch2.PatchSchema = z20.object({
+    patchText: z20.string().describe("The full patch text that describes all changes to be made")
+  });
+  let ApplyPatchError;
+  ((ApplyPatchError2) => {
+    ApplyPatchError2["ParseError"] = "ParseError";
+    ApplyPatchError2["IoError"] = "IoError";
+    ApplyPatchError2["ComputeReplacements"] = "ComputeReplacements";
+    ApplyPatchError2["ImplicitInvocation"] = "ImplicitInvocation";
+  })(ApplyPatchError = Patch2.ApplyPatchError || (Patch2.ApplyPatchError = {}));
+  let MaybeApplyPatch;
+  ((MaybeApplyPatch2) => {
+    MaybeApplyPatch2["Body"] = "Body";
+    MaybeApplyPatch2["ShellParseError"] = "ShellParseError";
+    MaybeApplyPatch2["PatchParseError"] = "PatchParseError";
+    MaybeApplyPatch2["NotApplyPatch"] = "NotApplyPatch";
+  })(MaybeApplyPatch = Patch2.MaybeApplyPatch || (Patch2.MaybeApplyPatch = {}));
+  let MaybeApplyPatchVerified;
+  ((MaybeApplyPatchVerified2) => {
+    MaybeApplyPatchVerified2["Body"] = "Body";
+    MaybeApplyPatchVerified2["ShellParseError"] = "ShellParseError";
+    MaybeApplyPatchVerified2["CorrectnessError"] = "CorrectnessError";
+    MaybeApplyPatchVerified2["NotApplyPatch"] = "NotApplyPatch";
+  })(MaybeApplyPatchVerified = Patch2.MaybeApplyPatchVerified || (Patch2.MaybeApplyPatchVerified = {}));
+  function parsePatchHeader(lines, startIdx) {
+    const line = lines[startIdx];
+    if (line.startsWith("*** Add File:")) {
+      const filePath = line.slice("*** Add File:".length).trim();
+      return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith("*** Delete File:")) {
+      const filePath = line.slice("*** Delete File:".length).trim();
+      return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith("*** Update File:")) {
+      const filePath = line.slice("*** Update File:".length).trim();
+      let movePath;
+      let nextIdx = startIdx + 1;
+      if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
+        movePath = lines[nextIdx].slice("*** Move to:".length).trim();
+        nextIdx++;
+      }
+      return filePath ? { filePath, movePath, nextIdx } : null;
+    }
+    return null;
+  }
+  function parseUpdateFileChunks(lines, startIdx) {
+    const chunks = [];
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+      if (lines[i].startsWith("@@")) {
+        const contextLine = lines[i].substring(2).trim();
+        i++;
+        const oldLines = [];
+        const newLines = [];
+        let isEndOfFile = false;
+        while (i < lines.length && !lines[i].startsWith("@@") && !lines[i].startsWith("***")) {
+          const changeLine = lines[i];
+          if (changeLine === "*** End of File") {
+            isEndOfFile = true;
+            i++;
+            break;
+          }
+          if (changeLine.startsWith(" ")) {
+            const content = changeLine.substring(1);
+            oldLines.push(content);
+            newLines.push(content);
+          } else if (changeLine.startsWith("-")) {
+            oldLines.push(changeLine.substring(1));
+          } else if (changeLine.startsWith("+")) {
+            newLines.push(changeLine.substring(1));
+          }
+          i++;
+        }
+        chunks.push({
+          old_lines: oldLines,
+          new_lines: newLines,
+          change_context: contextLine || void 0,
+          is_end_of_file: isEndOfFile || void 0
+        });
+      } else {
+        i++;
+      }
+    }
+    return { chunks, nextIdx: i };
+  }
+  function parseAddFileContent(lines, startIdx) {
+    let content = "";
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+      if (lines[i].startsWith("+")) {
+        content += lines[i].substring(1) + "\n";
+      }
+      i++;
+    }
+    if (content.endsWith("\n")) {
+      content = content.slice(0, -1);
+    }
+    return { content, nextIdx: i };
+  }
+  function stripHeredoc(input) {
+    const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/);
+    if (heredocMatch) {
+      return heredocMatch[2];
+    }
+    return input;
+  }
+  function parsePatch(patchText) {
+    const cleaned = stripHeredoc(patchText.trim());
+    const lines = cleaned.split("\n");
+    const hunks = [];
+    let i = 0;
+    const beginMarker = "*** Begin Patch";
+    const endMarker = "*** End Patch";
+    const beginIdx = lines.findIndex((line) => line.trim() === beginMarker);
+    const endIdx = lines.findIndex((line) => line.trim() === endMarker);
+    if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
+      throw new Error("Invalid patch format: missing Begin/End markers");
+    }
+    i = beginIdx + 1;
+    while (i < endIdx) {
+      const header = parsePatchHeader(lines, i);
+      if (!header) {
+        i++;
+        continue;
+      }
+      if (lines[i].startsWith("*** Add File:")) {
+        const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx);
+        hunks.push({
+          type: "add",
+          path: header.filePath,
+          contents: content
+        });
+        i = nextIdx;
+      } else if (lines[i].startsWith("*** Delete File:")) {
+        hunks.push({
+          type: "delete",
+          path: header.filePath
+        });
+        i = header.nextIdx;
+      } else if (lines[i].startsWith("*** Update File:")) {
+        const { chunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx);
+        hunks.push({
+          type: "update",
+          path: header.filePath,
+          move_path: header.movePath,
+          chunks
+        });
+        i = nextIdx;
+      } else {
+        i++;
+      }
+    }
+    return { hunks };
+  }
+  Patch2.parsePatch = parsePatch;
+  function maybeParseApplyPatch(argv) {
+    const APPLY_PATCH_COMMANDS = ["apply_patch", "applypatch"];
+    if (argv.length === 2 && APPLY_PATCH_COMMANDS.includes(argv[0])) {
+      try {
+        const { hunks } = parsePatch(argv[1]);
+        return {
+          type: "Body",
+          args: {
+            patch: argv[1],
+            hunks
+          }
+        };
+      } catch (error) {
+        return {
+          type: "PatchParseError",
+          error
+        };
+      }
+    }
+    if (argv.length === 3 && argv[0] === "bash" && argv[1] === "-lc") {
+      const script = argv[2];
+      const heredocMatch = script.match(/apply_patch\s*<<['"](\w+)['"]\s*\n([\s\S]*?)\n\1/);
+      if (heredocMatch) {
+        const patchContent = heredocMatch[2];
+        try {
+          const { hunks } = parsePatch(patchContent);
+          return {
+            type: "Body",
+            args: {
+              patch: patchContent,
+              hunks
+            }
+          };
+        } catch (error) {
+          return {
+            type: "PatchParseError",
+            error
+          };
+        }
+      }
+    }
+    return {
+      type: "NotApplyPatch"
+      /* NotApplyPatch */
+    };
+  }
+  Patch2.maybeParseApplyPatch = maybeParseApplyPatch;
+  async function deriveNewContentsFromChunks(context, filePath, chunks) {
+    let originalContent;
+    try {
+      originalContent = await Filesystem.readText(context, filePath);
+    } catch (error) {
+      throw new Error(`Failed to read file ${filePath}: ${error}`);
+    }
+    let originalLines = originalContent.split("\n");
+    if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
+      originalLines.pop();
+    }
+    const replacements = computeReplacements(originalLines, filePath, chunks);
+    let newLines = applyReplacements(originalLines, replacements);
+    if (newLines.length === 0 || newLines[newLines.length - 1] !== "") {
+      newLines.push("");
+    }
+    const newContent = newLines.join("\n");
+    const unifiedDiff = generateUnifiedDiff(originalContent, newContent);
+    return {
+      unified_diff: unifiedDiff,
+      content: newContent
+    };
+  }
+  Patch2.deriveNewContentsFromChunks = deriveNewContentsFromChunks;
+  function computeReplacements(originalLines, filePath, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+      if (chunk.change_context) {
+        const contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex);
+        if (contextIdx === -1) {
+          throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`);
+        }
+        lineIndex = contextIdx + 1;
+      }
+      if (chunk.old_lines.length === 0) {
+        const insertionIdx = originalLines.length > 0 && originalLines[originalLines.length - 1] === "" ? originalLines.length - 1 : originalLines.length;
+        replacements.push([insertionIdx, 0, chunk.new_lines]);
+        continue;
+      }
+      let pattern = chunk.old_lines;
+      let newSlice = chunk.new_lines;
+      let found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+      if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === "") {
+        pattern = pattern.slice(0, -1);
+        if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
+          newSlice = newSlice.slice(0, -1);
+        }
+        found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+      }
+      if (found !== -1) {
+        replacements.push([found, pattern.length, newSlice]);
+        lineIndex = found + pattern.length;
+      } else {
+        throw new Error(`Failed to find expected lines in ${filePath}:
+${chunk.old_lines.join("\n")}`);
+      }
+    }
+    replacements.sort((a, b) => a[0] - b[0]);
+    return replacements;
+  }
+  function applyReplacements(lines, replacements) {
+    const result = [...lines];
+    for (let i = replacements.length - 1; i >= 0; i--) {
+      const [startIdx, oldLen, newSegment] = replacements[i];
+      result.splice(startIdx, oldLen);
+      for (let j = 0; j < newSegment.length; j++) {
+        result.splice(startIdx + j, 0, newSegment[j]);
+      }
+    }
+    return result;
+  }
+  function normalizeUnicode(str) {
+    return str.replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, "-").replace(/\u2026/g, "...").replace(/\u00A0/g, " ");
+  }
+  function tryMatch(lines, pattern, startIndex, compare, eof) {
+    if (eof) {
+      const fromEnd = lines.length - pattern.length;
+      if (fromEnd >= startIndex) {
+        let matches = true;
+        for (let j = 0; j < pattern.length; j++) {
+          if (!compare(lines[fromEnd + j], pattern[j])) {
+            matches = false;
+            break;
+          }
+        }
+        if (matches) return fromEnd;
+      }
+    }
+    for (let i = startIndex; i <= lines.length - pattern.length; i++) {
+      let matches = true;
+      for (let j = 0; j < pattern.length; j++) {
+        if (!compare(lines[i + j], pattern[j])) {
+          matches = false;
+          break;
+        }
+      }
+      if (matches) return i;
+    }
+    return -1;
+  }
+  function seekSequence(lines, pattern, startIndex, eof = false) {
+    if (pattern.length === 0) return -1;
+    const exact = tryMatch(lines, pattern, startIndex, (a, b) => a === b, eof);
+    if (exact !== -1) return exact;
+    const rstrip = tryMatch(lines, pattern, startIndex, (a, b) => a.trimEnd() === b.trimEnd(), eof);
+    if (rstrip !== -1) return rstrip;
+    const trim = tryMatch(lines, pattern, startIndex, (a, b) => a.trim() === b.trim(), eof);
+    if (trim !== -1) return trim;
+    const normalized = tryMatch(
+      lines,
+      pattern,
+      startIndex,
+      (a, b) => normalizeUnicode(a.trim()) === normalizeUnicode(b.trim()),
+      eof
+    );
+    return normalized;
+  }
+  function generateUnifiedDiff(oldContent, newContent) {
+    const oldLines = oldContent.split("\n");
+    const newLines = newContent.split("\n");
+    let diff = "@@ -1 +1 @@\n";
+    const maxLen = Math.max(oldLines.length, newLines.length);
+    let hasChanges = false;
+    for (let i = 0; i < maxLen; i++) {
+      const oldLine = oldLines[i] || "";
+      const newLine = newLines[i] || "";
+      if (oldLine !== newLine) {
+        if (oldLine) diff += `-${oldLine}
+`;
+        if (newLine) diff += `+${newLine}
+`;
+        hasChanges = true;
+      } else if (oldLine) {
+        diff += ` ${oldLine}
+`;
+      }
+    }
+    return hasChanges ? diff : "";
+  }
+  async function applyHunksToFiles(context, hunks) {
+    if (hunks.length === 0) {
+      throw new Error("No files were modified.");
+    }
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    for (const hunk of hunks) {
+      switch (hunk.type) {
+        case "add":
+          const addDir = dirname(hunk.path);
+          if (addDir !== "." && addDir !== "/") {
+            await Filesystem.mkdir(context, addDir);
+          }
+          await Filesystem.write(context, hunk.path, hunk.contents);
+          added.push(hunk.path);
+          log2.info(`Added file: ${hunk.path}`);
+          break;
+        case "delete":
+          await Filesystem.remove(context, hunk.path);
+          deleted.push(hunk.path);
+          log2.info(`Deleted file: ${hunk.path}`);
+          break;
+        case "update":
+          const fileUpdate = await deriveNewContentsFromChunks(context, hunk.path, hunk.chunks);
+          if (hunk.move_path) {
+            const moveDir = dirname(hunk.move_path);
+            if (moveDir !== "." && moveDir !== "/") {
+              await Filesystem.mkdir(context, moveDir);
+            }
+            await Filesystem.write(context, hunk.move_path, fileUpdate.content);
+            await Filesystem.remove(context, hunk.path);
+            modified.push(hunk.move_path);
+            log2.info(`Moved file: ${hunk.path} -> ${hunk.move_path}`);
+          } else {
+            await Filesystem.write(context, hunk.path, fileUpdate.content);
+            modified.push(hunk.path);
+            log2.info(`Updated file: ${hunk.path}`);
+          }
+          break;
+      }
+    }
+    return { added, modified, deleted };
+  }
+  Patch2.applyHunksToFiles = applyHunksToFiles;
+  async function applyPatch(context, patchText) {
+    const { hunks } = parsePatch(patchText);
+    return applyHunksToFiles(context, hunks);
+  }
+  Patch2.applyPatch = applyPatch;
+  async function maybeParseApplyPatchVerified(context, argv, cwd) {
+    if (argv.length === 1) {
+      try {
+        parsePatch(argv[0]);
+        return {
+          type: "CorrectnessError",
+          error: new Error(
+            "ImplicitInvocation"
+            /* ImplicitInvocation */
+          )
+        };
+      } catch {
+      }
+    }
+    const result = maybeParseApplyPatch(argv);
+    switch (result.type) {
+      case "Body":
+        const { args } = result;
+        const effectiveCwd = args.workdir ? resolve(cwd, args.workdir) : cwd;
+        const changes = /* @__PURE__ */ new Map();
+        for (const hunk of args.hunks) {
+          const resolvedPath = resolve(
+            effectiveCwd,
+            hunk.type === "update" && hunk.move_path ? hunk.move_path : hunk.path
+          );
+          switch (hunk.type) {
+            case "add":
+              changes.set(resolvedPath, {
+                type: "add",
+                content: hunk.contents
+              });
+              break;
+            case "delete":
+              const deletePath = resolve(effectiveCwd, hunk.path);
+              try {
+                const content = await Filesystem.readText(context, deletePath);
+                changes.set(resolvedPath, {
+                  type: "delete",
+                  content
+                });
+              } catch (error) {
+                return {
+                  type: "CorrectnessError",
+                  error: new Error(`Failed to read file for deletion: ${deletePath}`)
+                };
+              }
+              break;
+            case "update":
+              const updatePath = resolve(effectiveCwd, hunk.path);
+              try {
+                const fileUpdate = await deriveNewContentsFromChunks(context, updatePath, hunk.chunks);
+                changes.set(resolvedPath, {
+                  type: "update",
+                  unified_diff: fileUpdate.unified_diff,
+                  move_path: hunk.move_path ? resolve(effectiveCwd, hunk.move_path) : void 0,
+                  new_content: fileUpdate.content
+                });
+              } catch (error) {
+                return {
+                  type: "CorrectnessError",
+                  error
+                };
+              }
+              break;
+          }
+        }
+        return {
+          type: "Body",
+          action: {
+            changes,
+            patch: args.patch,
+            cwd: effectiveCwd
+          }
+        };
+      case "PatchParseError":
+        return {
+          type: "CorrectnessError",
+          error: result.error
+        };
+      case "NotApplyPatch":
+        return {
+          type: "NotApplyPatch"
+          /* NotApplyPatch */
+        };
+    }
+  }
+  Patch2.maybeParseApplyPatchVerified = maybeParseApplyPatchVerified;
+})(Patch || (Patch = {}));
+var apply_patch_txt_default = `Use the \`apply_patch\` tool to edit files. Your patch language is a stripped\u2011down, file\u2011oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high\u2011level envelope:
+
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+\`\`\`
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+\`\`\`
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with \`+\` even when creating a new file
+`;
+var PatchParams = z21.object({
+  patchText: z21.string().describe("The full patch text that describes all changes to be made")
+});
+var ApplyPatchTool = Tool.define("apply_patch", {
+  description: apply_patch_txt_default,
+  parameters: PatchParams,
+  async execute(params, ctx) {
+    if (!params.patchText) {
+      throw new Error("patchText is required");
+    }
+    let hunks;
+    try {
+      const parseResult = Patch.parsePatch(params.patchText);
+      hunks = parseResult.hunks;
+    } catch (error) {
+      throw new Error(`apply_patch verification failed: ${error}`);
+    }
+    if (hunks.length === 0) {
+      const normalized = params.patchText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+      if (normalized === "*** Begin Patch\n*** End Patch") {
+        throw new Error("patch rejected: empty patch");
+      }
+      throw new Error("apply_patch verification failed: no hunks found");
+    }
+    const fileChanges = [];
+    let totalDiff = "";
+    for (const hunk of hunks) {
+      const filePath = resolve(ctx.directory, hunk.path);
+      await assertExternalDirectory(ctx, filePath);
+      switch (hunk.type) {
+        case "add": {
+          const oldContent = "";
+          const newContent = hunk.contents.length === 0 || hunk.contents.endsWith("\n") ? hunk.contents : `${hunk.contents}
+`;
+          const diff = trimDiff(createTwoFilesPatch3(filePath, filePath, oldContent, newContent));
+          let additions = 0;
+          let deletions = 0;
+          for (const change of diffLines2(oldContent, newContent)) {
+            if (change.added) additions += change.count || 0;
+            if (change.removed) deletions += change.count || 0;
+          }
+          fileChanges.push({
+            filePath,
+            oldContent,
+            newContent,
+            type: "add",
+            diff,
+            additions,
+            deletions
+          });
+          totalDiff += diff + "\n";
+          break;
+        }
+        case "update": {
+          const stats = await ctx.fs.stat(filePath);
+          if (!stats || stats.isDirectory) {
+            throw new Error(`apply_patch verification failed: Failed to read file to update: ${filePath}`);
+          }
+          const oldContent = await ctx.fs.readText(filePath);
+          let newContent = oldContent;
+          try {
+            const fileUpdate = await Patch.deriveNewContentsFromChunks(ctx, filePath, hunk.chunks);
+            newContent = fileUpdate.content;
+          } catch (error) {
+            throw new Error(`apply_patch verification failed: ${error}`);
+          }
+          const diff = trimDiff(createTwoFilesPatch3(filePath, filePath, oldContent, newContent));
+          let additions = 0;
+          let deletions = 0;
+          for (const change of diffLines2(oldContent, newContent)) {
+            if (change.added) additions += change.count || 0;
+            if (change.removed) deletions += change.count || 0;
+          }
+          const movePath = hunk.move_path ? resolve(ctx.directory, hunk.move_path) : void 0;
+          await assertExternalDirectory(ctx, movePath);
+          fileChanges.push({
+            filePath,
+            oldContent,
+            newContent,
+            type: hunk.move_path ? "move" : "update",
+            movePath,
+            diff,
+            additions,
+            deletions
+          });
+          totalDiff += diff + "\n";
+          break;
+        }
+        case "delete": {
+          const contentToDelete = await ctx.fs.readText(filePath).catch((error) => {
+            throw new Error(`apply_patch verification failed: ${error}`);
+          });
+          const deleteDiff = trimDiff(createTwoFilesPatch3(filePath, filePath, contentToDelete, ""));
+          const deletions = contentToDelete.split("\n").length;
+          fileChanges.push({
+            filePath,
+            oldContent: contentToDelete,
+            newContent: "",
+            type: "delete",
+            diff: deleteDiff,
+            additions: 0,
+            deletions
+          });
+          totalDiff += deleteDiff + "\n";
+          break;
+        }
+      }
+    }
+    const files = fileChanges.map((change) => ({
+      filePath: change.filePath,
+      relativePath: relative(ctx.worktree, change.movePath ?? change.filePath).replaceAll("\\", "/"),
+      type: change.type,
+      diff: change.diff,
+      before: change.oldContent,
+      after: change.newContent,
+      additions: change.additions,
+      deletions: change.deletions,
+      movePath: change.movePath
+    }));
+    const relativePaths = fileChanges.map((c) => relative(ctx.worktree, c.filePath).replaceAll("\\", "/"));
+    await ctx.ask({
+      permission: "edit",
+      patterns: relativePaths,
+      always: ["*"],
+      metadata: {
+        filepath: relativePaths.join(", "),
+        diff: totalDiff,
+        files
+      }
+    });
+    const updates = [];
+    for (const change of fileChanges) {
+      const edited = change.type === "delete" ? void 0 : change.movePath ?? change.filePath;
+      switch (change.type) {
+        case "add":
+          await ctx.fs.mkdir(dirname(change.filePath));
+          await ctx.fs.write(change.filePath, change.newContent);
+          updates.push({ file: change.filePath, event: "add" });
+          break;
+        case "update":
+          await ctx.fs.write(change.filePath, change.newContent);
+          updates.push({ file: change.filePath, event: "change" });
+          break;
+        case "move":
+          if (change.movePath) {
+            await ctx.fs.mkdir(dirname(change.movePath));
+            await ctx.fs.write(change.movePath, change.newContent);
+            await ctx.fs.remove(change.filePath);
+            updates.push({ file: change.filePath, event: "unlink" });
+            updates.push({ file: change.movePath, event: "add" });
+          }
+          break;
+        case "delete":
+          await ctx.fs.remove(change.filePath);
+          updates.push({ file: change.filePath, event: "unlink" });
+          break;
+      }
+      if (edited) {
+        ctx.emit("file.edited", { file: edited });
+      }
+    }
+    for (const change of fileChanges) {
+      if (change.type === "delete") continue;
+      const target = change.movePath ?? change.filePath;
+      await LSP.touchFile(target, true);
+    }
+    const diagnostics = await LSP.diagnostics();
+    const summaryLines = fileChanges.map((change) => {
+      if (change.type === "add") {
+        return `A ${relative(ctx.worktree, change.filePath).replaceAll("\\", "/")}`;
+      }
+      if (change.type === "delete") {
+        return `D ${relative(ctx.worktree, change.filePath).replaceAll("\\", "/")}`;
+      }
+      const target = change.movePath ?? change.filePath;
+      return `M ${relative(ctx.worktree, target).replaceAll("\\", "/")}`;
+    });
+    let output = `Success. Updated the following files:
+${summaryLines.join("\n")}`;
+    const MAX_DIAGNOSTICS_PER_FILE3 = 20;
+    for (const change of fileChanges) {
+      if (change.type === "delete") continue;
+      const target = change.movePath ?? change.filePath;
+      const normalized = target;
+      const issues = diagnostics.get(normalized) ?? [];
+      const errors = issues.filter((item) => item.severity === 1);
+      if (errors.length > 0) {
+        const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE3);
+        const suffix = errors.length > MAX_DIAGNOSTICS_PER_FILE3 ? `
+... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE3} more` : "";
+        output += `
+
+LSP errors detected in ${relative(ctx.worktree, target).replaceAll("\\", "/")}, please fix:
+<diagnostics file="${target}">
+${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}
+</diagnostics>`;
+      }
+    }
+    return {
+      title: output,
+      metadata: {
+        diff: totalDiff,
+        files,
+        diagnostics
+      },
+      output
+    };
+  }
+});
+var terminal_write_txt_default = `Send input to the shared user terminal, or create/destroy it.
+
+This tool interacts with a single shared terminal (PTY) that is also visible to the user.
+
+## Actions
+
+- **type="create"**: Spawn a new terminal. Fails if one already exists. You must create a terminal before sending input.
+- **type="destroy"**: Kill the current terminal. Use this when the terminal is stuck or unresponsive, then create a new one. Fails if no terminal exists.
+- **type="input"**: Send text to the terminal. By default, Enter is pressed after the input (pressEnter=true). Set pressEnter=false for partial input or answering prompts like y/n.
+
+## Important
+- In most cases, prefer the **bash** tool for running commands. It is faster, captures output directly, and does not require creating/destroying a terminal.
+- Use terminal_write/terminal_read when you need a **persistent, stateful shell session**, e.g. running a long-lived dev server for preview, interactive REPL, or commands that depend on prior shell state.
+
+## Usage notes
+- The terminal is shared with the user \u2014 they can see everything you type and you can see their output.
+- Always create a terminal before sending commands.
+- If a long-running command is stuck, destroy and recreate the terminal.
+- For commands that produce output, use the terminal_read tool after sending input to see the results.
+- When answering interactive prompts (e.g. "Continue? [y/n]"), set pressEnter=false if the program reads single characters, or pressEnter=true if it expects a line.
+`;
+var TerminalWriteTool = Tool.define("terminal_write", async () => {
+  return {
+    description: terminal_write_txt_default,
+    parameters: z22.object({
+      type: z22.enum(["input", "create", "destroy"]).describe(
+        'The type of action. "input" sends text to the terminal. "create" spawns a new terminal (errors if one already exists). "destroy" kills the current terminal (errors if none exists).'
+      ),
+      content: z22.string().describe('The text to send to the terminal. Required when type is "input".').optional(),
+      pressEnter: z22.boolean().describe("Whether to press Enter after the input. Defaults to true.").optional()
+    }),
+    async execute(params, ctx) {
+      const terminal = ctx.terminal;
+      if (params.type === "create") {
+        terminal.create();
+        return {
+          title: "Create terminal",
+          metadata: { type: "create" },
+          output: "Terminal created successfully."
+        };
+      }
+      if (params.type === "destroy") {
+        terminal.destroy();
+        return {
+          title: "Destroy terminal",
+          metadata: { type: "destroy" },
+          output: "Terminal destroyed successfully."
+        };
+      }
+      if (!params.content && params.content !== "") {
+        throw new Error('The "content" parameter is required when type is "input".');
+      }
+      if (!terminal.exists()) {
+        throw new Error('No terminal exists. Use type "create" first.');
+      }
+      const pressEnter = params.pressEnter ?? true;
+      const data = pressEnter ? params.content + "\n" : params.content;
+      terminal.write(data);
+      return {
+        title: params.content.length > 60 ? params.content.slice(0, 57) + "..." : params.content,
+        metadata: {
+          type: "input",
+          content: params.content,
+          pressEnter
+        },
+        output: `Input sent to terminal.`
+      };
+    }
+  };
+});
+var terminal_read_txt_default = `Read the terminal output from the bottom of the buffer.
+
+Returns the last N lines from the shared user terminal. Use this after sending a command via terminal_write to see its output.
+
+## Parameters
+- **length**: How many lines to read from the bottom. Start with a small number (e.g. 20-50) and increase if you need more context.
+- **waitBefore**: Milliseconds to wait before reading. Use this to let a command finish producing output. Defaults to 0. Maximum is 5000ms (values above 5000 are clamped to 5000).
+
+## Important
+- In most cases, prefer the **bash** tool for running commands \u2014 it captures output directly without needing terminal_read.
+- Use terminal_read when reading output from a persistent terminal session (e.g. a dev server for preview) started via terminal_write.
+
+## Usage notes
+- The terminal must exist (created via terminal_write type="create") before reading.
+- If output looks truncated or the command hasn't finished, just call terminal_read again \u2014 the terminal is persistent.
+- Lines are returned as plain text, one per line.
+`;
+var TerminalReadTool = Tool.define("terminal_read", async () => {
+  return {
+    description: terminal_read_txt_default,
+    parameters: z23.object({
+      length: z23.number().int().min(1).describe("Number of lines to read from the bottom of the terminal buffer."),
+      waitBefore: z23.number().int().min(0).describe("Milliseconds to wait before reading. Use this to let a command finish producing output. Defaults to 0.").optional()
+    }),
+    async execute(params, ctx) {
+      const terminal = ctx.terminal;
+      if (!terminal.exists()) {
+        throw new Error('No terminal exists. Use terminal_write with type "create" first.');
+      }
+      const MAX_WAIT = 5e3;
+      const waitMs = Math.min(params.waitBefore ?? 0, MAX_WAIT);
+      if (waitMs > 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, waitMs));
+      }
+      const content = terminal.read(params.length);
+      return {
+        title: `Read ${params.length} lines`,
+        metadata: {
+          length: params.length,
+          waitBefore: waitMs
+        },
+        output: content || "(terminal buffer is empty)"
+      };
+    }
+  };
+});
+var set_preview_url_txt_default = `Set the preview URL for the user's preview panel.
+
+This tool configures a reverse proxy so the user can preview a locally running web application directly in the IDE's preview tab. A dedicated preview port on the server proxies all requests to the given local URL.
+
+## Parameters
+- **forwarded_local_url**: The absolute local URL to reverse-proxy to (e.g. "http://localhost:5173" for Vite, "http://localhost:3000" for React).
+
+## Usage notes
+- Use this after starting a local dev server (e.g. via terminal_write) to let the user see the result.
+- The preview tab will automatically load the proxied page.
+- Calling this again will update the target and refresh the preview.
+`;
+var SetPreviewUrlTool = Tool.define("set_preview_url", async () => {
+  return {
+    description: set_preview_url_txt_default,
+    parameters: z24.object({
+      forwarded_local_url: z24.string().describe('The absolute local URL to reverse-proxy to (e.g. "http://localhost:5173").')
+    }),
+    async execute(params, ctx) {
+      ctx.preview.setPreviewTarget(params.forwarded_local_url);
+      return {
+        title: `Preview \u2192 ${params.forwarded_local_url}`,
+        metadata: {
+          forwarded_local_url: params.forwarded_local_url
+        },
+        output: `Preview proxy set to "${params.forwarded_local_url}". The user's preview tab will load this automatically.`
+      };
+    }
+  };
+});
+var ToolRegistry;
+((ToolRegistry2) => {
+  const log2 = Log.create({ service: "tool.registry" });
+  class ToolRegistryService {
+    _promise;
+    context;
+    constructor(context) {
+      this.context = context;
+      this._promise = initTools(context);
+    }
+    async register(tool) {
+      const { custom } = await this._promise;
+      const idx = custom.findIndex((t) => t.id === tool.id);
+      if (idx >= 0) {
+        custom.splice(idx, 1, tool);
+        return;
+      }
+      custom.push(tool);
+    }
+    async tools(model, agent) {
+      return ToolRegistry2.tools(this.context, model, agent);
+    }
+  }
+  ToolRegistry2.ToolRegistryService = ToolRegistryService;
+  async function initTools(context) {
+    const custom = [];
+    return { custom };
+  }
+  function fromPlugin(id, def) {
+    return {
+      id,
+      init: async (initCtx) => ({
+        parameters: z25.object(def.args),
+        description: def.description,
+        execute: async (args, ctx) => {
+          const pluginCtx = {
+            ...ctx,
+            directory: ctx.directory,
+            worktree: ctx.worktree
+          };
+          const result = await def.execute(args, pluginCtx);
+          const out = await Truncate.output(ctx, result, {}, initCtx?.agent);
+          return {
+            title: "",
+            output: out.truncated ? out.content : result,
+            metadata: { truncated: out.truncated, outputPath: out.truncated ? out.outputPath : void 0 }
+          };
+        }
+      })
+    };
+  }
+  async function all(context) {
+    const custom = await context.toolRegistry._promise.then((x) => x.custom);
+    const config = context.config;
+    return [
+      InvalidTool,
+      SetWorkingDirectoryTool,
+      BashTool,
+      ReadTool,
+      GlobTool,
+      GrepTool,
+      EditTool,
+      WriteTool,
+      WebFetchTool,
+      TodoWriteTool,
+      // TodoReadTool,
+      WebSearchTool,
+      CodeSearchTool,
+      SkillTool,
+      ApplyPatchTool,
+      TerminalWriteTool,
+      TerminalReadTool,
+      SetPreviewUrlTool,
+      ...config.experimental?.batch_tool === true ? [BatchTool] : [],
+      ...Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool] : [],
+      ...custom
+    ];
+  }
+  async function ids(context) {
+    return all(context).then((x) => x.map((t) => t.id));
+  }
+  ToolRegistry2.ids = ids;
+  async function tools(context, model, agent) {
+    const tools2 = await all(context);
+    const result = await Promise.all(
+      tools2.filter((t) => {
+        if (t.id === "codesearch" || t.id === "websearch") {
+          return model.providerID === ProviderID.opencode || Flag.OPENCODE_ENABLE_EXA;
+        }
+        const usePatch = model.modelID.includes("gpt-") && !model.modelID.includes("oss") && !model.modelID.includes("gpt-4");
+        if (t.id === "apply_patch") return usePatch;
+        if (t.id === "edit" || t.id === "write") return !usePatch;
+        return true;
+      }).map(async (t) => {
+        var _stack = [];
+        try {
+          const _ = __using(_stack, log2.time(t.id));
+          const tool = await t.init({ agent, agentContext: context });
+          const output = {
+            description: tool.description,
+            parameters: tool.parameters
+          };
+          return {
+            id: t.id,
+            ...tool,
+            description: output.description,
+            parameters: output.parameters
+          };
+        } catch (_2) {
+          var _error = _2, _hasError = true;
+        } finally {
+          __callDispose(_stack, _error, _hasError);
+        }
+      })
+    );
+    return result;
+  }
+  ToolRegistry2.tools = tools;
+})(ToolRegistry || (ToolRegistry = {}));
+
+export {
+  SchedulerService,
+  Tool,
+  SetWorkingDirectoryTool,
+  ReadTool,
+  ConfigMarkdown,
+  Discovery,
+  Skill,
+  ToolRegistry
+};