@agentscope-ai/agentscope 0.0.2

package/dist/tool/index.mjs

@@ -0,0 +1,1447 @@
+// src/tool/response.ts
+function createToolResponse({
+  content,
+  state,
+  id = crypto.randomUUID(),
+  createdAt = (/* @__PURE__ */ new Date()).toISOString(),
+  metadata = {},
+  stream = false,
+  isLast = true,
+  isInterrupted = false
+}) {
+  return {
+    content,
+    id,
+    createdAt,
+    metadata,
+    state,
+    stream,
+    isLast,
+    isInterrupted
+  };
+}
+function isToolResponse(obj) {
+  return obj && typeof obj === "object" && typeof obj.id === "string" && typeof obj.createdAt === "string" && Array.isArray(obj.content) && typeof obj.metadata === "object" && typeof obj.stream === "boolean" && typeof obj.isLast === "boolean" && typeof obj.isInterrupted === "boolean" && ["success", "error", "interrupted", "running"].includes(obj.state);
+}
+
+// src/tool/toolkit.ts
+import * as fs from "fs";
+import * as path from "path";
+import { Validator } from "@cfworker/json-schema";
+import matter from "gray-matter";
+import { z } from "zod";
+
+// src/_utils/common.ts
+import { jsonrepair } from "jsonrepair";
+function _jsonLoadsWithRepair(input) {
+  try {
+    const jsonObj = JSON.parse(input);
+    if (typeof jsonObj === "object" && jsonObj !== null && !Array.isArray(jsonObj)) {
+      return jsonObj;
+    } else {
+      return {};
+    }
+  } catch {
+    try {
+      const repairedString = jsonrepair(input);
+      const jsonObj = JSON.parse(repairedString);
+      if (typeof jsonObj === "object" && jsonObj !== null && !Array.isArray(jsonObj)) {
+        return jsonObj;
+      } else {
+        return {};
+      }
+    } catch (e) {
+      console.error(`Failed to parse JSON "${input}" with error:`, e);
+      return {};
+    }
+  }
+}
+
+// src/tool/toolkit.ts
+var Toolkit = class {
+  tools;
+  skills;
+  skillDirs;
+  // The cache mapping from the skill name to its corresponding tool name in the toolkit.
+  _skillCache;
+  /**
+   * Initializes a new instance of the Toolkit class.
+   * @param config - The configuration object for initializing the toolkit, which can include an array of tools, an array of skill paths, an array of skill directory paths, and a boolean indicating whether to include the built-in skill tool for reading SKILL.md files.
+   * @param config.tools - An array of tool definitions to register in the toolkit.
+   * @param config.skills - An array of file paths pointing to individual skills.
+   * @param config.skillDirs - An array of directory paths, where each directory can contain multiple skills in its subdirectories.
+   * @param config.builtInSkillTool - A boolean flag indicating whether to include the built-in skill tool for reading SKILL.md files.
+   */
+  constructor(config) {
+    const { tools = [], skills = [], skillDirs = [], builtInSkillTool = true } = config || {};
+    this.tools = [];
+    if (builtInSkillTool) {
+      this.tools.push({
+        type: "function",
+        name: "Skill",
+        description: `Retrieves the full content of a skill by reading its SKILL.md file. Skills are packages of domain expertise that extend agent capabilities. Use this tool to access detailed instructions, examples, and guidelines for a specific skill.
+
+Usage:
+- Provide the skill name as the input parameter
+- The tool will return the complete SKILL.md file content for that skill
+- If the skill is not found, an error message with available skills will be returned
+- Available skills are listed in the skills-system section of the agent prompt`,
+        inputSchema: z.object({ name: z.string().describe("The name of the skill") }),
+        call: this._skillTool.bind(this),
+        requireUserConfirm: false
+      });
+    }
+    tools.map((tool) => {
+      this.tools.push({
+        type: "function",
+        ...tool
+      });
+    });
+    this.skills = skills;
+    this.skillDirs = skillDirs;
+    this._skillCache = {};
+  }
+  /**
+   * Registers a tool function to the toolkit. The function can be either a plain function that adheres to the ToolFunction type, or an instance of a class that extends ToolBase. When registering a plain function, the name, description, and input schema must be provided explicitly. When registering a ToolBase instance, these properties will be extracted from the instance itself.
+   *
+   * @params tool - The tool function to register, which can be either a plain function with explicit properties or an instance of a class that extends ToolBase.
+   * @returns The Toolkit instance with the new tool function registered
+   * @param tool
+   */
+  registerToolFunction(tool) {
+    this.tools.push({
+      type: "function",
+      ...tool
+    });
+    return this;
+  }
+  /**
+   * Registers functions from a given MCP client.
+   *
+   * @param root0
+   * @param root0.client
+   * @param root0.enabledTools
+   * @param root0.disabledTools
+   * @param root0.requireUserConfirm
+   * @returns The Toolkit instance with the new tools registered
+   */
+  async registerMCPClient({
+    client,
+    enabledTools,
+    disabledTools = [],
+    requireUserConfirm = false
+  }) {
+    const tools = await client.listTools();
+    const appendTools = [];
+    tools.filter(
+      (tool) => !(enabledTools && !enabledTools.includes(tool.name)) && !disabledTools.includes(tool.name)
+    ).forEach((tool) => {
+      this.tools.push({
+        type: "mcp",
+        mcpName: client.name,
+        ...tool,
+        requireUserConfirm
+      });
+      appendTools.push(tool.name);
+    });
+    console.log(`Registered tools from MCP client '${client.name}': ${appendTools.join(", ")}`);
+    return this;
+  }
+  /**
+   * Executes a registered tool function based on the provided ToolUseBlock.
+   * Note this method always returns an AsyncGenerator of ToolResponse, regardless of the tool function type.
+   *
+   * @param toolCall - The ToolUseBlock containing the tool name and input arguments
+   * @yields Incremental ToolResponse objects as they are produced by the tool function
+   * @returns The final complete ToolResponse after the tool function execution is finished
+   */
+  async *callToolFunction(toolCall) {
+    const tool = this.tools.find((tool2) => tool2.name === toolCall.name);
+    if (!tool) {
+      const notFoundRes = createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `FunctionNotFoundError: Cannot find the function named ${toolCall.name}`
+          }
+        ],
+        state: "error"
+      });
+      yield notFoundRes;
+      return notFoundRes;
+    }
+    let parsedInput;
+    try {
+      parsedInput = _jsonLoadsWithRepair(toolCall.input);
+      if (tool.inputSchema instanceof z.ZodObject) {
+        tool.inputSchema.parse(parsedInput);
+      } else {
+        const validator = new Validator(tool.inputSchema);
+        const validation = validator.validate(parsedInput);
+        if (!validation.valid) {
+          throw new Error(`Invalid input arguments: ${validation.errors}`);
+        }
+      }
+    } catch (error) {
+      const parseErrorRes = createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `InvalidArgumentError: ${String(error)}`
+          }
+        ],
+        state: "error"
+      });
+      yield parseErrorRes;
+      return parseErrorRes;
+    }
+    if (!tool.call) {
+      throw new Error(
+        `Cannot execute external tool '${toolCall.name}' because no call method is defined for it in the toolkit.`
+      );
+    }
+    let finalRes = null;
+    try {
+      const res = await tool.call(parsedInput);
+      if (typeof res === "string") {
+        const textRes = createToolResponse({
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: res
+            }
+          ],
+          state: "success"
+        });
+        yield textRes;
+        finalRes = textRes;
+      } else if (isToolResponse(res)) {
+        yield res;
+        finalRes = res;
+      } else if (Symbol.asyncIterator in res) {
+        const accContent = [];
+        let nextResult = await res.next();
+        while (!nextResult.done) {
+          const currentValue = nextResult.value;
+          nextResult = await res.next();
+          const isLastValue = nextResult.done;
+          if (typeof currentValue === "string") {
+            const itemRes = createToolResponse({
+              content: [
+                {
+                  id: crypto.randomUUID(),
+                  type: "text",
+                  text: currentValue
+                }
+              ],
+              isLast: isLastValue,
+              state: "running"
+            });
+            yield itemRes;
+            accContent.push({
+              id: crypto.randomUUID(),
+              type: "text",
+              text: currentValue
+            });
+          } else if (isToolResponse(currentValue)) {
+            currentValue.isLast = currentValue.isLast ?? isLastValue;
+            yield currentValue;
+            accContent.push(...currentValue.content);
+          }
+        }
+        finalRes = createToolResponse({
+          content: accContent,
+          state: "success"
+        });
+      } else if (Symbol.iterator in res) {
+        const accContent = [];
+        let nextResult = res.next();
+        while (!nextResult.done) {
+          const currentValue = nextResult.value;
+          nextResult = res.next();
+          const isLastValue = nextResult.done;
+          if (typeof currentValue === "string") {
+            const itemRes = createToolResponse({
+              content: [
+                {
+                  id: crypto.randomUUID(),
+                  type: "text",
+                  text: currentValue
+                }
+              ],
+              isLast: isLastValue,
+              state: "running"
+            });
+            yield itemRes;
+            accContent.push({
+              id: crypto.randomUUID(),
+              type: "text",
+              text: currentValue
+            });
+          } else if (isToolResponse(currentValue)) {
+            currentValue.isLast = currentValue.isLast ?? isLastValue;
+            yield currentValue;
+            accContent.push(...currentValue.content);
+          }
+        }
+        finalRes = createToolResponse({
+          content: accContent,
+          state: "success"
+        });
+      } else {
+        const invalidRes = createToolResponse({
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: String(res)
+            }
+          ],
+          state: "running"
+        });
+        yield invalidRes;
+        finalRes = invalidRes;
+      }
+    } catch (error) {
+      const errorRes = createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `ToolExecutionError: ${String(error)}`
+          }
+        ],
+        state: "error"
+      });
+      yield errorRes;
+      finalRes = errorRes;
+    }
+    if (!finalRes) {
+      return createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `Tool ${toolCall.name} executed successfully.`
+          }
+        ],
+        state: "success"
+      });
+    }
+    const cleanedContent = [];
+    let textBuffer = "";
+    for (const block of finalRes.content) {
+      if (block.type === "text") {
+        textBuffer += block.text;
+      } else {
+        if (textBuffer) {
+          cleanedContent.push({
+            id: crypto.randomUUID(),
+            type: "text",
+            text: textBuffer
+          });
+          textBuffer = "";
+        }
+        cleanedContent.push(block);
+      }
+    }
+    if (textBuffer) {
+      cleanedContent.push({
+        id: crypto.randomUUID(),
+        type: "text",
+        text: textBuffer
+      });
+    }
+    return {
+      ...finalRes,
+      content: cleanedContent
+    };
+  }
+  /**
+   * Returns the JSON schemas for all registered tools in a format compatible with LLM APIs.
+   *
+   * @returns An array of ToolJSONSchema objects
+   */
+  getJSONSchemas() {
+    return this.tools.map((tool) => {
+      const inputSchema = tool.inputSchema instanceof z.ZodObject ? tool.inputSchema.toJSONSchema({ target: "openapi-3.0" }) : tool.inputSchema;
+      return {
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: inputSchema
+        }
+      };
+    });
+  }
+  /**
+   * Get the instruction prompt for the agent to use the skills.
+   *
+   * @returns A string containing the instruction prompt of the available skills and how to use them.
+   */
+  getSkillsPrompt() {
+    this._skillCache = {};
+    if (this.skills.length === 0 && this.skillDirs.length === 0) return "";
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      const skillsInfo = [];
+      this.skills.forEach((skillPath) => {
+        const absSkillPath = path.resolve(skillPath);
+        if (!fs.existsSync(absSkillPath) || !fs.statSync(absSkillPath).isDirectory()) {
+          return;
+        }
+        const skillMdPath = path.join(absSkillPath, "SKILL.md");
+        if (!fs.existsSync(skillMdPath)) return;
+        try {
+          const content = fs.readFileSync(skillMdPath, "utf-8");
+          const { data } = matter(content);
+          const name = data.name || path.basename(skillPath);
+          const description = data.description || "No description provided";
+          skillsInfo.push({
+            name,
+            description,
+            location: absSkillPath
+          });
+          this._skillCache[name] = absSkillPath;
+        } catch (e) {
+          console.error(`Error reading SKILL.md for skill at ${skillPath}:`, e);
+        }
+      });
+      this.skillDirs.forEach((skillDir) => {
+        const absSkillDir = path.resolve(skillDir);
+        if (!fs.existsSync(absSkillDir) || !fs.statSync(absSkillDir).isDirectory()) {
+          return;
+        }
+        const subdirs = fs.readdirSync(absSkillDir).filter((subdir) => {
+          const subdirPath = path.join(absSkillDir, subdir);
+          return fs.statSync(subdirPath).isDirectory();
+        });
+        subdirs.forEach((subdir) => {
+          const skillMdPath = path.join(absSkillDir, subdir, "SKILL.md");
+          if (!fs.existsSync(skillMdPath)) return;
+          try {
+            const content = fs.readFileSync(skillMdPath, "utf-8");
+            const { data } = matter(content);
+            const name = data.name || subdir;
+            const description = data.description || "No description provided";
+            skillsInfo.push({
+              name,
+              description,
+              location: path.join(skillDir, subdir)
+            });
+            this._skillCache[name] = path.join(absSkillDir, subdir);
+          } catch (e) {
+            console.error(
+              `Error reading SKILL.md for skill at ${path.join(skillDir, subdir)}:`,
+              e
+            );
+          }
+        });
+      });
+      if (skillsInfo.length === 0) return "";
+      const skillsXml = skillsInfo.map(
+        (skill) => `<skill>
+<name>${skill.name}</name>
+<description>${skill.description}</description>
+<location>${skill.location}</location>
+</skill>`
+      ).reduce((acc, skillInfo) => acc + `
+${skillInfo}
+`, "");
+      return `<skills-system>
+## What are Skills?
+Skills are packages of domain expertise that extend your capabilities.
+
+## Important: How to Use Skills
+**Skill names are NOT callable functions.** You cannot call a skill directly by its name.
+${skillsXml}
+</skills-system>`;
+    }
+    return "";
+  }
+  /**
+   * The agent skill tool to read SKILL.md file content based on the skill name.
+   * @param root0
+   * @param root0.name
+   * @returns The content of the SKILL.md file for the specified skill, or an error message if the skill is not
+   * found or the SKILL.md file cannot be read.
+   */
+  async _skillTool({ name }) {
+    if (this._skillCache[name]) {
+      const skillDir = this._skillCache[name];
+      const skillMdPath = path.join(skillDir, "SKILL.md");
+      if (!fs.existsSync(skillMdPath)) {
+        try {
+          const fileContent = fs.readFileSync(skillMdPath, "utf-8");
+          return createToolResponse({
+            content: [
+              {
+                id: crypto.randomUUID(),
+                type: "text",
+                text: fileContent
+              }
+            ],
+            state: "success"
+          });
+        } catch {
+        }
+      }
+    }
+    this.getSkillsPrompt();
+    const refreshedSkillDir = this._skillCache[name];
+    if (refreshedSkillDir) {
+      const skillMdPath = path.join(refreshedSkillDir, "SKILL.md");
+      try {
+        const fileContent = fs.readFileSync(skillMdPath, "utf-8");
+        return createToolResponse({
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: fileContent
+            }
+          ],
+          state: "success"
+        });
+      } catch {
+      }
+    }
+    return createToolResponse({
+      content: [
+        {
+          id: crypto.randomUUID(),
+          type: "text",
+          text: `SkillNotFoundError: Cannot find the skill named ${name}, current available skills are ${Object.keys(this._skillCache).join(", ")}`
+        }
+      ],
+      state: "error"
+    });
+  }
+  /**
+   * Checks if a tool requires user confirmation before execution based on its name.
+   * @param toolName The name of the tool to check for user confirmation requirement.
+   * @returns A boolean indicating whether the specified tool requires user confirmation before execution. If the tool is not found, it returns false.
+   */
+  requireUserConfirm(toolName) {
+    const tool = this.tools.find((tool2) => tool2.name === toolName);
+    return tool ? tool.requireUserConfirm ?? false : false;
+  }
+  /**
+   * Checks if a tool requires external execution (e.g., by an MCP client) based on its name.
+   * @param toolName
+   * @returns A boolean indicating whether the specified tool requires external execution. If the tool is not found, it returns false.
+   */
+  requireExternalExecution(toolName) {
+    const tool = this.tools.find((tool2) => tool2.name === toolName);
+    return tool ? !tool.call : false;
+  }
+};
+
+// src/tool/bash.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z as z2 } from "zod";
+var execAsync = promisify(exec);
+function Bash() {
+  return {
+    name: "Bash",
+    description: `Executes a given bash command and returns its output.
+
+The working directory persists between commands, but shell state does not. The shell environment is initialized from the user's profile (bash or zsh).
+
+IMPORTANT: Avoid using this tool to run \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or after you have verified that a dedicated tool cannot accomplish your task. Instead, use the appropriate dedicated tool as this will provide a much better experience for the user:
+
+ - 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)
+
+While the Bash tool can do similar things, it's better to use the built-in tools as they provide a better user experience and make it easier to review tool calls and give permission.
+
+# Instructions
+ - If your command will create new directories or files, first use this tool to run \`ls\` to verify the parent directory exists and is the correct location.
+ - Always quote file paths that contain spaces with double quotes in your command (e.g., cd "path with spaces/file.txt")
+ - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it.
+ - You may specify an optional timeout in milliseconds (up to 600000ms / 10 minutes). By default, your command will timeout after 120000ms (2 minutes).
+ - Write a clear, concise description of what your command does. For simple commands, keep it brief (5-10 words). For complex commands (piped commands, obscure flags, or anything hard to understand at a glance), include enough context so that the user can understand what your command will do.
+ - When issuing multiple commands:
+  - If the commands are independent and can run in parallel, make multiple Bash tool calls in a single message. 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.
+  - 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).
+ - For git commands:
+  - Prefer to create a new commit rather than amending an existing commit.
+  - Before running destructive operations (e.g., git reset --hard, git push --force, git checkout --), consider whether there is a safer alternative that achieves the same goal. Only use destructive operations when they are truly the best approach.
+  - Never skip hooks (--no-verify) or bypass signing (--no-gpg-sign, -c commit.gpgsign=false) unless the user has explicitly asked for it. If a hook fails, investigate and fix the underlying issue.
+ - Avoid unnecessary \`sleep\` commands:
+  - Do not sleep between commands that can run immediately \u2014 just run them.
+  - Do not retry failing commands in a sleep loop \u2014 diagnose the root cause or consider an alternative approach.
+  - If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.`,
+    inputSchema: z2.object({
+      command: z2.string().describe("The bash command to execute"),
+      description: z2.string().optional().describe(
+        "Clear, concise description of what this command does. For simple commands, keep it brief (5-10 words). For complex commands, include enough context."
+      ),
+      timeout: z2.number().int().min(0).max(6e5).optional().describe("Optional timeout in milliseconds (default: 120000, max: 600000)")
+    }),
+    requireUserConfirm: true,
+    /**
+     * Executes a bash command and returns its output.
+     *
+     * @param root0 - The parameters object
+     * @param root0.command - The bash command to execute
+     * @param root0.description - Optional description of what the command does
+     * @param root0.timeout - Optional timeout in milliseconds (default: 120000, max: 600000)
+     * @returns The stdout of the command, or an error message if the command fails
+     */
+    async call({
+      command,
+      description: _description,
+      timeout = 12e4
+    }) {
+      try {
+        const maxTimeout = 6e5;
+        const effectiveTimeout = Math.min(timeout, maxTimeout);
+        let shell;
+        if (process.platform === "win32") {
+          shell = process.env.COMSPEC || "cmd.exe";
+        } else {
+          shell = process.env.SHELL || "/bin/bash";
+        }
+        const { stdout } = await execAsync(command, {
+          encoding: "utf-8",
+          timeout: effectiveTimeout,
+          maxBuffer: 3e4 * 1024,
+          shell
+        });
+        const normalizedOutput = stdout.replace(/\r\n/g, "\n");
+        const maxOutputLength = 3e4;
+        if (normalizedOutput.length > maxOutputLength) {
+          return createToolResponse({
+            content: [
+              {
+                id: crypto.randomUUID(),
+                type: "text",
+                text: normalizedOutput.substring(0, maxOutputLength) + "\n\n[Output truncated - exceeded 30000 characters]"
+              }
+            ],
+            state: "success"
+          });
+        }
+        return createToolResponse({
+          content: [{ id: crypto.randomUUID(), type: "text", text: normalizedOutput }],
+          state: "success"
+        });
+      } catch (error) {
+        const errorMessage = error.message || "Unknown error";
+        const stderr = error.stderr?.toString().replace(/\r\n/g, "\n") || "";
+        const stdout = error.stdout?.toString().replace(/\r\n/g, "\n") || "";
+        let result = `Command failed: ${command}
+`;
+        if (stdout) result += `
+Stdout:
+${stdout}`;
+        if (stderr) result += `
+Stderr:
+${stderr}`;
+        if (errorMessage && !stderr) result += `
+Error: ${errorMessage}`;
+        return createToolResponse({
+          content: [{ id: crypto.randomUUID(), type: "text", text: result }],
+          state: "error"
+        });
+      }
+    }
+  };
+}
+
+// src/tool/read.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { z as z3 } from "zod";
+function Read() {
+  return {
+    name: "Read",
+    description: `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to 2000 lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Any lines longer than 2000 characters will be truncated
+- Results are returned using cat -n format, with line numbers starting at 1
+- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
+- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`,
+    inputSchema: z3.object({
+      file_path: z3.string().describe("The absolute path to the file to read"),
+      offset: z3.number().int().positive().optional().describe(
+        "The line number to start reading from. Only provide if the file is too large to read at once"
+      ),
+      limit: z3.number().int().positive().optional().describe(
+        "The number of lines to read. Only provide if the file is too large to read at once"
+      )
+    }),
+    requireUserConfirm: true,
+    /**
+     * Reads a file and returns its contents with line numbers.
+     *
+     * @param root0 - The parameters object
+     * @param root0.file_path - Absolute path to the file to read
+     * @param root0.offset - Line number to start reading from (1-based)
+     * @param root0.limit - Maximum number of lines to read (capped at 2000)
+     * @returns The file contents formatted with line numbers, or a warning if the file is empty
+     * @throws If the path is not absolute, the file does not exist, or the path is a directory
+     */
+    call({
+      file_path,
+      offset,
+      limit
+    }) {
+      if (!path2.isAbsolute(file_path)) {
+        throw new Error(`file_path must be an absolute path, got: ${file_path}`);
+      }
+      if (!fs2.existsSync(file_path)) {
+        throw new Error(`File not found: ${file_path}`);
+      }
+      const stat = fs2.statSync(file_path);
+      if (stat.isDirectory()) {
+        throw new Error(
+          `${file_path} is a directory, not a file. Use Bash with ls to read directories.`
+        );
+      }
+      const rawContent = fs2.readFileSync(file_path, "utf-8");
+      if (rawContent.length === 0) {
+        return createToolResponse({
+          content: [{ id: crypto.randomUUID(), type: "text", text: rawContent }],
+          state: "success"
+        });
+      }
+      const allLines = rawContent.split("\n");
+      const startLine = offset !== void 0 ? offset - 1 : 0;
+      const maxLines = 2e3;
+      const effectiveLimit = limit !== void 0 ? Math.min(limit, maxLines) : maxLines;
+      const selectedLines = allLines.slice(startLine, startLine + effectiveLimit);
+      const maxLineLength = 2e3;
+      const formatted = selectedLines.map((line, i) => {
+        const lineNum = startLine + i + 1;
+        const truncated = line.length > maxLineLength ? line.substring(0, maxLineLength) + "[truncated]" : line;
+        return `${String(lineNum).padStart(6)}	${truncated}`;
+      }).join("\n");
+      return createToolResponse({
+        content: [{ id: crypto.randomUUID(), type: "text", text: formatted }],
+        state: "success"
+      });
+    }
+  };
+}
+
+// src/tool/write.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { z as z4 } from "zod";
+function Write() {
+  return {
+    name: "Write",
+    description: `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.`,
+    inputSchema: z4.object({
+      file_path: z4.string().describe(
+        "The absolute path to the file to write (must be absolute, not relative)"
+      ),
+      content: z4.string().describe("The content to write to the file")
+    }),
+    requireUserConfirm: true,
+    /**
+     * Writes content to a file, creating parent directories if necessary.
+     *
+     * @param root0 - The parameters object
+     * @param root0.file_path - Absolute path to the file to write
+     * @param root0.content - The content to write to the file
+     * @returns A success message including the number of lines written
+     * @throws If the path is not absolute
+     */
+    call({ file_path, content }) {
+      if (!path3.isAbsolute(file_path)) {
+        throw new Error(`file_path must be an absolute path, got: ${file_path}`);
+      }
+      const dir = path3.dirname(file_path);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
+      }
+      fs3.writeFileSync(file_path, content, "utf-8");
+      const lineCount = content.split("\n").length;
+      return `The file ${file_path} has been written successfully (${lineCount} lines).`;
+    }
+  };
+}
+
+// src/tool/edit.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { z as z5 } from "zod";
+function Edit() {
+  return {
+    name: "Edit",
+    description: `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: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- 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 \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`,
+    inputSchema: z5.object({
+      file_path: z5.string().describe("The absolute path to the file to modify"),
+      old_string: z5.string().describe("The text to replace"),
+      new_string: z5.string().describe("The text to replace it with (must be different from old_string)"),
+      replace_all: z5.boolean().optional().default(false).describe("Replace all occurrences of old_string (default false)")
+    }),
+    requireUserConfirm: true,
+    /**
+     * Performs an exact string replacement in the specified file.
+     *
+     * @param root0 - The parameters object
+     * @param root0.file_path - Absolute path to the file to modify
+     * @param root0.old_string - The exact text to find and replace
+     * @param root0.new_string - The text to replace old_string with
+     * @param root0.replace_all - If true, replaces all occurrences; otherwise only the first
+     * @returns A success message indicating the file was updated
+     * @throws If the path is not absolute, file does not exist, strings are identical,
+     *         old_string is not found, or old_string is not unique and replace_all is false
+     */
+    call({
+      file_path,
+      old_string,
+      new_string,
+      replace_all = false
+    }) {
+      if (!path4.isAbsolute(file_path)) {
+        throw new Error(`file_path must be an absolute path, got: ${file_path}`);
+      }
+      if (!fs4.existsSync(file_path)) {
+        throw new Error(`File not found: ${file_path}`);
+      }
+      if (old_string === new_string) {
+        throw new Error("old_string and new_string must be different");
+      }
+      const content = fs4.readFileSync(file_path, "utf-8");
+      const occurrences = content.split(old_string).length - 1;
+      if (occurrences === 0) {
+        throw new Error(`old_string not found in file: ${file_path}`);
+      }
+      if (!replace_all && occurrences > 1) {
+        throw new Error(
+          `old_string is not unique in the file (found ${occurrences} occurrences). Provide more surrounding context to make it unique, or use replace_all=true.`
+        );
+      }
+      const newContent = replace_all ? content.split(old_string).join(new_string) : content.replace(old_string, new_string);
+      fs4.writeFileSync(file_path, newContent, "utf-8");
+      return `The file ${file_path} has been updated successfully.`;
+    }
+  };
+}
+
+// src/tool/glob.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { z as z6 } from "zod";
+function Glob() {
+  const globMatch = (pattern, baseDir) => {
+    const results = [];
+    const parts = pattern.split("/");
+    matchParts(parts, 0, baseDir, results);
+    return results;
+  };
+  const matchParts = (parts, partIndex, currentDir, results) => {
+    if (partIndex >= parts.length) return;
+    const part = parts[partIndex];
+    const isLast = partIndex === parts.length - 1;
+    if (part === "**") {
+      if (isLast) {
+        collectAll(currentDir, results);
+      } else {
+        matchParts(parts, partIndex + 1, currentDir, results);
+        try {
+          const entries = fs5.readdirSync(currentDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              const subDir = path5.join(currentDir, entry.name);
+              matchParts(parts, partIndex, subDir, results);
+            }
+          }
+        } catch {
+        }
+      }
+    } else {
+      const regex = globPartToRegex(part);
+      try {
+        const entries = fs5.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (regex.test(entry.name)) {
+            const fullPath = path5.join(currentDir, entry.name);
+            if (isLast) {
+              if (entry.isFile()) results.push(fullPath);
+            } else if (entry.isDirectory()) {
+              matchParts(parts, partIndex + 1, fullPath, results);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  };
+  const collectAll = (dir, results) => {
+    try {
+      const entries = fs5.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path5.join(dir, entry.name);
+        if (entry.isFile()) {
+          results.push(fullPath);
+        } else if (entry.isDirectory()) {
+          collectAll(fullPath, results);
+        }
+      }
+    } catch {
+    }
+  };
+  const globPartToRegex = (part) => {
+    const escaped = part.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+  };
+  return {
+    name: "Glob",
+    description: `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 Agent tool instead
+- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.`,
+    inputSchema: 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.'
+      )
+    }),
+    requireUserConfirm: true,
+    /**
+     * Finds files matching a glob pattern under the given directory.
+     *
+     * @param root0 - The parameters object
+     * @param root0.pattern - The glob pattern to match files against
+     * @param root0.path - The base directory to search in; defaults to cwd
+     * @returns A newline-separated list of matching file paths sorted by modification time,
+     *          or a no-matches message if nothing is found
+     * @throws If the base directory does not exist
+     */
+    call({ pattern, path: searchPath }) {
+      const baseDir = searchPath ? searchPath : process.cwd();
+      if (!fs5.existsSync(baseDir)) {
+        throw new Error(`Directory not found: ${baseDir}`);
+      }
+      const matches = globMatch(pattern, baseDir);
+      matches.sort((a, b) => {
+        const statA = fs5.statSync(a);
+        const statB = fs5.statSync(b);
+        return statB.mtimeMs - statA.mtimeMs;
+      });
+      if (matches.length === 0) {
+        return `No files found matching pattern: ${pattern}`;
+      }
+      return matches.join("\n");
+    }
+  };
+}
+
+// src/tool/grep.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { z as z7 } from "zod";
+var TYPE_EXTENSIONS = {
+  js: [".js", ".mjs", ".cjs"],
+  ts: [".ts", ".mts", ".cts"],
+  tsx: [".tsx"],
+  jsx: [".jsx"],
+  py: [".py"],
+  rust: [".rs"],
+  go: [".go"],
+  java: [".java"],
+  cpp: [".cpp", ".cc", ".cxx", ".h", ".hpp"],
+  c: [".c", ".h"],
+  css: [".css"],
+  html: [".html", ".htm"],
+  json: [".json"],
+  md: [".md", ".markdown"],
+  yaml: [".yaml", ".yml"],
+  toml: [".toml"],
+  sh: [".sh", ".bash"]
+};
+function Grep() {
+  const collectFiles = (baseDir, glob, type) => {
+    const results = [];
+    const extensions = type ? TYPE_EXTENSIONS[type] : void 0;
+    const walk = (dir) => {
+      let entries;
+      try {
+        entries = fs6.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        const fullPath = path6.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else if (entry.isFile()) {
+          if (extensions) {
+            const ext = path6.extname(entry.name);
+            if (extensions.includes(ext)) results.push(fullPath);
+          } else if (glob) {
+            if (matchGlob(glob, entry.name)) results.push(fullPath);
+          } else {
+            results.push(fullPath);
+          }
+        }
+      }
+    };
+    if (fs6.existsSync(baseDir) && fs6.statSync(baseDir).isFile()) {
+      results.push(baseDir);
+    } else {
+      walk(baseDir);
+    }
+    return results;
+  };
+  const matchGlob = (pattern, filename) => {
+    const braceMatch = pattern.match(/\*\.\\{(.+)\\}/);
+    if (braceMatch) {
+      const exts = braceMatch[1].split(",").map((e) => `.${e.trim()}`);
+      return exts.includes(path6.extname(filename));
+    }
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`).test(filename);
+  };
+  return {
+    name: "Grep",
+    description: `A powerful search tool built on regular expressions.
+
+Usage:
+- ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command. The Grep tool has been optimized for correct permissions and access.
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+- Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
+- Use Task tool for open-ended searches requiring multiple rounds
+- Pattern syntax: Uses ripgrep-style regex - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
+- Multiline matching: By default patterns match within single lines only. For cross-line patterns, use \`multiline: true\``,
+    inputSchema: z7.object({
+      pattern: z7.string().describe("The regular expression pattern to search for in file contents"),
+      path: z7.string().optional().describe("File or directory to search in. Defaults to current working directory."),
+      glob: z7.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
+      type: z7.string().optional().describe(
+        'File type to search (e.g., "js", "ts", "py"). More efficient than glob for standard file types.'
+      ),
+      output_mode: z7.enum(["content", "files_with_matches", "count"]).optional().describe(
+        'Output mode: "content" | "files_with_matches" | "count". Defaults to "files_with_matches".'
+      ),
+      multiline: z7.boolean().optional().describe(
+        "Enable multiline mode where . matches newlines and patterns can span lines. Default: false."
+      ),
+      case_insensitive: z7.boolean().optional().describe("Case insensitive search. Default: false."),
+      context: z7.number().int().optional().describe(
+        'Number of lines to show before and after each match. Requires output_mode: "content".'
+      ),
+      head_limit: z7.number().int().optional().describe("Limit output to first N lines/entries.")
+    }),
+    requireUserConfirm: true,
+    /**
+     * Searches files for a regex pattern and returns results in the specified output mode.
+     *
+     * @param root0 - The parameters object
+     * @param root0.pattern - The regular expression pattern to search for
+     * @param root0.path - File or directory to search in; defaults to cwd
+     * @param root0.glob - Glob pattern to filter which files are searched
+     * @param root0.type - File type shorthand (e.g. "ts", "py") to filter files
+     * @param root0.output_mode - How to format results: "content", "files_with_matches", or "count"
+     * @param root0.multiline - Whether the pattern can span multiple lines
+     * @param root0.case_insensitive - Whether the search is case-insensitive
+     * @param root0.context - Number of surrounding lines to include with each match
+     * @param root0.head_limit - Maximum number of result entries to return
+     * @returns A newline-separated string of results, or a no-matches message
+     */
+    call({
+      pattern,
+      path: searchPath,
+      glob,
+      type,
+      output_mode = "files_with_matches",
+      multiline = false,
+      case_insensitive = false,
+      context,
+      head_limit
+    }) {
+      const baseDir = searchPath ? searchPath : process.cwd();
+      let flags = multiline ? "gms" : "gm";
+      if (case_insensitive) flags += "i";
+      const regex = new RegExp(pattern, flags);
+      const files = collectFiles(baseDir, glob, type);
+      if (files.length === 0) {
+        return "No files found to search.";
+      }
+      const results = [];
+      for (const file of files) {
+        try {
+          const content = fs6.readFileSync(file, "utf-8");
+          if (output_mode === "files_with_matches") {
+            if (regex.test(content)) {
+              results.push(file);
+            }
+            regex.lastIndex = 0;
+          } else if (output_mode === "count") {
+            const matches = content.match(regex);
+            if (matches) {
+              results.push(`${file}: ${matches.length}`);
+            }
+            regex.lastIndex = 0;
+          } else if (output_mode === "content") {
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+              const lineRegex = new RegExp(pattern, case_insensitive ? "i" : "");
+              if (lineRegex.test(lines[i])) {
+                const start = context !== void 0 ? Math.max(0, i - context) : i;
+                const end = context !== void 0 ? Math.min(lines.length - 1, i + context) : i;
+                for (let j = start; j <= end; j++) {
+                  results.push(`${file}:${j + 1}:${lines[j]}`);
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (results.length === 0) {
+        return `No matches found for pattern: ${pattern}`;
+      }
+      const output = head_limit !== void 0 ? results.slice(0, head_limit) : results;
+      return output.join("\n");
+    }
+  };
+}
+
+// src/tool/task.ts
+import { z as z8 } from "zod";
+var taskStore = /* @__PURE__ */ new Map();
+var nextId = 1;
+function generateId() {
+  return String(nextId++);
+}
+function TaskCreate() {
+  return {
+    name: "TaskCreate",
+    description: `Use this tool to create 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:
+
+- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+- User explicitly requests todo list - When the user directly asks you to use the todo list
+- User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+
+All tasks are created with status 'pending'.`,
+    inputSchema: z8.object({
+      subject: z8.string().describe(
+        'A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")'
+      ),
+      description: z8.string().describe(
+        "Detailed description of what needs to be done, including context and acceptance criteria"
+      ),
+      activeForm: z8.string().optional().describe(
+        'Present continuous form shown in the spinner when the task is in_progress (e.g., "Fixing authentication bug"). If omitted, the spinner shows the subject instead.'
+      ),
+      metadata: z8.record(z8.string(), z8.unknown()).optional().describe("Arbitrary metadata to attach to the task")
+    }),
+    requireUserConfirm: false,
+    call({
+      subject,
+      description,
+      activeForm,
+      metadata
+    }) {
+      const id = generateId();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const task = {
+        id,
+        subject,
+        description,
+        status: "pending",
+        activeForm,
+        metadata,
+        blocks: [],
+        blockedBy: [],
+        createdAt: now,
+        updatedAt: now
+      };
+      taskStore.set(id, task);
+      return createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `Task #${id} created successfully: ${subject}`
+          }
+        ],
+        state: "success"
+      });
+    }
+  };
+}
+function TaskUpdate() {
+  return {
+    name: "TaskUpdate",
+    description: `Use this tool to update a task in the task list.
+
+## When to Use This Tool
+
+**Mark tasks as resolved:**
+- When you have completed the work described in a task
+- When a task is no longer needed or has been superseded
+- IMPORTANT: Always mark your assigned tasks as resolved when you finish them
+
+**Delete tasks:**
+- When a task is no longer relevant or was created in error
+- Setting status to 'deleted' permanently removes the task
+
+**Update task details:**
+- When requirements change or become clearer
+- When establishing dependencies between tasks`,
+    inputSchema: z8.object({
+      taskId: z8.string().describe("The ID of the task to update"),
+      status: z8.enum(["pending", "in_progress", "completed", "deleted"]).optional().describe("New status for the task"),
+      subject: z8.string().optional().describe("New subject for the task"),
+      description: z8.string().optional().describe("New description for the task"),
+      activeForm: z8.string().optional().describe(
+        'Present continuous form shown in spinner when in_progress (e.g., "Running tests")'
+      ),
+      owner: z8.string().optional().describe("New owner for the task"),
+      metadata: z8.record(z8.string(), z8.unknown()).optional().describe("Metadata keys to merge into the task. Set a key to null to delete it."),
+      addBlocks: z8.array(z8.string()).optional().describe("Task IDs that this task blocks"),
+      addBlockedBy: z8.array(z8.string()).optional().describe("Task IDs that block this task")
+    }),
+    requireUserConfirm: false,
+    call({
+      taskId,
+      status,
+      subject,
+      description,
+      activeForm,
+      owner,
+      metadata,
+      addBlocks,
+      addBlockedBy
+    }) {
+      const task = taskStore.get(taskId);
+      if (!task) {
+        throw new Error(`Task not found: ${taskId}`);
+      }
+      if (addBlocks) {
+        for (const depId of addBlocks) {
+          if (!taskStore.has(depId)) {
+            throw new Error(`Cannot add dependency: task ${depId} does not exist`);
+          }
+        }
+      }
+      if (addBlockedBy) {
+        for (const depId of addBlockedBy) {
+          if (!taskStore.has(depId)) {
+            throw new Error(`Cannot add dependency: task ${depId} does not exist`);
+          }
+        }
+      }
+      if (subject !== void 0) task.subject = subject;
+      if (description !== void 0) task.description = description;
+      if (activeForm !== void 0) task.activeForm = activeForm;
+      if (owner !== void 0) task.owner = owner;
+      if (metadata !== void 0) {
+        if (!task.metadata) {
+          task.metadata = {};
+        }
+        for (const [key, value] of Object.entries(metadata)) {
+          if (value === null) {
+            delete task.metadata[key];
+          } else {
+            task.metadata[key] = value;
+          }
+        }
+      }
+      if (addBlocks) {
+        task.blocks = [.../* @__PURE__ */ new Set([...task.blocks, ...addBlocks])];
+      }
+      if (addBlockedBy) {
+        task.blockedBy = [.../* @__PURE__ */ new Set([...task.blockedBy, ...addBlockedBy])];
+      }
+      task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (status !== void 0) {
+        if (status === "deleted") {
+          taskStore.delete(taskId);
+          return createToolResponse({
+            content: [
+              {
+                id: crypto.randomUUID(),
+                type: "text",
+                text: `Task #${taskId} deleted successfully`
+              }
+            ],
+            state: "success"
+          });
+        }
+        task.status = status;
+      }
+      return createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: `Task #${taskId} updated successfully`
+          }
+        ],
+        state: "success"
+      });
+    }
+  };
+}
+function TaskGet() {
+  return {
+    name: "TaskGet",
+    description: `Use this tool to retrieve a task by its ID from the task list.
+
+## When to Use This Tool
+
+- When you need the full description and context before starting work on a task
+- To understand task dependencies (what it blocks, what blocks it)
+- After being assigned a task, to get complete requirements`,
+    inputSchema: z8.object({
+      taskId: z8.string().describe("The ID of the task to retrieve")
+    }),
+    requireUserConfirm: false,
+    call({ taskId }) {
+      const task = taskStore.get(taskId);
+      if (!task) {
+        throw new Error(`Task not found: ${taskId}`);
+      }
+      let text = `Task #${task.id}: ${task.subject}
+`;
+      text += `Status: ${task.status}
+`;
+      text += `Description: ${task.description}
+`;
+      if (task.activeForm) {
+        text += `Active Form: ${task.activeForm}
+`;
+      }
+      if (task.owner) {
+        text += `Owner: ${task.owner}
+`;
+      }
+      if (task.blocks.length > 0) {
+        text += `Blocks: ${task.blocks.join(", ")}
+`;
+      }
+      if (task.blockedBy.length > 0) {
+        text += `Blocked By: ${task.blockedBy.join(", ")}
+`;
+      }
+      if (task.metadata && Object.keys(task.metadata).length > 0) {
+        text += `Metadata: ${JSON.stringify(task.metadata, null, 2)}
+`;
+      }
+      text += `Created: ${task.createdAt}
+`;
+      text += `Updated: ${task.updatedAt}`;
+      return createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text
+          }
+        ],
+        state: "success"
+      });
+    }
+  };
+}
+function TaskList() {
+  return {
+    name: "TaskList",
+    description: `Use this tool to list all tasks in the task list.
+
+## When to Use This Tool
+
+- To see what tasks are available to work on (status: 'pending', no owner, not blocked)
+- To check overall progress on the project
+- To find tasks that are blocked and need dependencies resolved
+- After completing a task, to check for newly unblocked work or claim the next available task`,
+    inputSchema: z8.object({}),
+    requireUserConfirm: false,
+    call() {
+      const activeTasks = Array.from(taskStore.values()).filter((task) => task.status === "pending" || task.status === "in_progress").sort((a, b) => Number(a.id) - Number(b.id));
+      if (activeTasks.length === 0) {
+        return createToolResponse({
+          content: [
+            {
+              id: crypto.randomUUID(),
+              type: "text",
+              text: "No active tasks found"
+            }
+          ],
+          state: "success"
+        });
+      }
+      const lines = activeTasks.map((task) => {
+        let line = `#${task.id} [${task.status}] ${task.subject}`;
+        if (task.blockedBy.length > 0) {
+          line += ` (blocked by: #${task.blockedBy.join(", #")})`;
+        }
+        return line;
+      });
+      return createToolResponse({
+        content: [
+          {
+            id: crypto.randomUUID(),
+            type: "text",
+            text: lines.join("\n")
+          }
+        ],
+        state: "success"
+      });
+    }
+  };
+}
+export {
+  Bash,
+  Edit,
+  Glob,
+  Grep,
+  Read,
+  TaskCreate,
+  TaskGet,
+  TaskList,
+  TaskUpdate,
+  Toolkit,
+  Write
+};
+//# sourceMappingURL=index.mjs.map