@amical/aiagent-sdk 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,951 @@
+import { nanoid } from 'nanoid';
+import matter from 'gray-matter';
+
+// src/shared/tools.ts
+var AgentDefaultTool = /* @__PURE__ */ ((AgentDefaultTool2) => {
+  AgentDefaultTool2["ASK"] = "agent_ask_followup_question";
+  AgentDefaultTool2["ATTEMPT"] = "agent_attempt_completion";
+  AgentDefaultTool2["BASH"] = "agent_execute_command";
+  AgentDefaultTool2["FILE_EDIT"] = "agent_replace_in_file";
+  AgentDefaultTool2["FILE_READ"] = "agent_read_file";
+  AgentDefaultTool2["FILE_NEW"] = "agent_write_to_file";
+  AgentDefaultTool2["FILE_DELETE"] = "agent_delete_file";
+  AgentDefaultTool2["DIR_DELETE"] = "agent_delete_directory";
+  AgentDefaultTool2["SEARCH"] = "agent_search_files";
+  AgentDefaultTool2["LIST_FILES"] = "agent_list_files";
+  AgentDefaultTool2["LIST_CODE_DEF"] = "agent_list_code_definition_names";
+  AgentDefaultTool2["BROWSER"] = "agent_browser_action";
+  AgentDefaultTool2["MCP_USE"] = "agent_use_mcp_tool";
+  AgentDefaultTool2["MCP_ACCESS"] = "agent_access_mcp_resource";
+  AgentDefaultTool2["MCP_DOCS"] = "agent_load_mcp_documentation";
+  AgentDefaultTool2["NEW_TASK"] = "agent_new_task";
+  AgentDefaultTool2["PLAN_MODE"] = "agent_plan_mode_respond";
+  AgentDefaultTool2["ACT_MODE"] = "agent_act_mode_respond";
+  AgentDefaultTool2["TODO"] = "agent_focus_chain";
+  AgentDefaultTool2["WEB_FETCH"] = "agent_web_fetch";
+  AgentDefaultTool2["WEB_SEARCH"] = "agent_web_search";
+  AgentDefaultTool2["CONDENSE"] = "agent_condense";
+  AgentDefaultTool2["SUMMARIZE_TASK"] = "agent_summarize_task";
+  AgentDefaultTool2["REPORT_BUG"] = "agent_report_bug";
+  AgentDefaultTool2["NEW_RULE"] = "agent_new_rule";
+  AgentDefaultTool2["APPLY_PATCH"] = "agent_apply_patch";
+  AgentDefaultTool2["GENERATE_EXPLANATION"] = "agent_generate_explanation";
+  AgentDefaultTool2["LOAD_SKILL"] = "agent_load_skill";
+  AgentDefaultTool2["USE_SUBAGENTS"] = "agent_use_subagents";
+  return AgentDefaultTool2;
+})(AgentDefaultTool || {});
+var TOOL_RESULT_BLOCK = "tool_call_result";
+var defaultTools = [
+  {
+    name: "agent_ask_followup_question" /* ASK */,
+    description: "Ask the user a clarifying question if more information is needed.",
+    params: {
+      question: "The question to ask the user."
+    }
+  },
+  {
+    name: "agent_attempt_completion" /* ATTEMPT */,
+    description: "After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. Optionally you may provide a CLI command to showcase the result of your work. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again. IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must ask yourself in tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool. If you were using task_progress to update the task progress, you must include the completed list in the result as well.",
+    params: {
+      result: "(required) The result of the tool use. This should be a clear, specific description of the result."
+    },
+    example: `## Example: ${"agent_attempt_completion" /* ATTEMPT */}
+<${"agent_attempt_completion" /* ATTEMPT */}>
+<result>final result or message</result>
+<task_progress>
+- [x] Set up project structure
+- [x] Install dependencies
+- [x] Run command to start server
+- [x] Test application
+</task_progress>
+</${"agent_attempt_completion" /* ATTEMPT */}>`
+  },
+  {
+    name: "agent_execute_command" /* BASH */,
+    description: "Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. For command chaining, use the appropriate chaining syntax for the user's shell. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will be executed in the current working directory: ${context.cwd} Use @workspace:path syntax (e.g., @frontend:src/index.ts) to specify a workspace.",
+    params: {
+      command: "(required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions."
+    },
+    example: `## Example: Requesting to execute a command
+
+<${"agent_execute_command" /* BASH */}>
+<command>npm run dev</command>
+<requires_approval>false</requires_approval>
+<task_progress>
+- [x] Set up project structure
+- [x] Install dependencies
+- [ ] Run command to start server
+- [ ] Test application
+</task_progress>
+</${"agent_execute_command" /* BASH */}>`
+  },
+  {
+    name: "agent_replace_in_file" /* FILE_EDIT */,
+    description: "Replace specific content in a file using a search/replace diff block.",
+    params: {
+      path: "(required) The absolute or relative file path to modify.",
+      diff: "(required) The diff content to apply."
+    },
+    example: `## Example: Requesting to make targeted edits to a file
+
+<${"agent_replace_in_file" /* FILE_EDIT */}>
+<path>src/components/App.tsx</path>
+<diff>
+------- SEARCH
+import React from 'react';
+=======
+import React, { useState } from 'react';
++++++++ REPLACE
+
+------- SEARCH
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+=======
++++++++ REPLACE
+
+------- SEARCH
+return (
+  <div>
+=======
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+return (
+  <div>
++++++++ REPLACE
+</diff>
+<task_progress>
+- [x] Set up project structure
+- [x] Install dependencies
+- [ ] Create components
+- [ ] Test application
+</task_progress>
+</${"agent_replace_in_file" /* FILE_EDIT */}>`
+  },
+  {
+    name: "agent_read_file" /* FILE_READ */,
+    description: "Read the contents of a specific file.",
+    params: {
+      path: "(required) The absolute or relative file path to read."
+    }
+  },
+  {
+    name: "agent_write_to_file" /* FILE_NEW */,
+    description: "Create or overwrite a file with new content.",
+    params: {
+      path: "(required) The path of the file to write to (relative to the current working directory ${context.cwd}) Use @workspace:path syntax (e.g., @frontend:src/index.ts) to specify a workspace.",
+      content: "(required) The content to write to the file."
+    },
+    example: `## Example: Requesting to create a new file
+
+<${"agent_write_to_file" /* FILE_NEW */}>
+<path>src/frontend-config.json</path>
+<content>
+{
+  "apiEndpoint": "https://api.example.com",
+  "theme": {
+    "primaryColor": "#007bff",
+    "secondaryColor": "#6c757d",
+    "fontFamily": "Arial, sans-serif"
+  },
+  "features": {
+    "darkMode": true,
+    "notifications": true,
+    "analytics": false
+  },
+  "version": "1.0.0"
+}
+</content>
+<task_progress>
+- [x] Set up project structure
+- [x] Install dependencies
+- [x] Create components
+- [ ] Test application
+</task_progress>
+</${"agent_write_to_file" /* FILE_NEW */}>`
+  },
+  {
+    name: "agent_delete_file" /* FILE_DELETE */,
+    description: "Delete a file.",
+    params: {
+      path: "(required) The path of the file to delete to (relative to the current working directory ${context.cwd}) Use @workspace:path syntax (e.g., @frontend:src/index.ts) to specify a workspace."
+    }
+  },
+  {
+    name: "agent_delete_directory" /* DIR_DELETE */,
+    description: "Delete a directory.",
+    params: {
+      path: "(required) The path of the directory to delete to (relative to the current working directory ${context.cwd}) Use @workspace:path syntax (e.g., @frontend:src/index.ts) to specify a workspace."
+    }
+  },
+  {
+    name: "agent_search_files" /* SEARCH */,
+    description: "Search for files in a directory that match a regex pattern or glob pattern.",
+    params: {
+      path: "(required) The absolute or relative directory path to search.",
+      regex: "(required) The regex pattern to match files against.",
+      file_pattern: "(optional) glob pattern like *.ts."
+    }
+  },
+  {
+    name: "agent_list_files" /* LIST_FILES */,
+    description: "List all files in a directory.",
+    params: {
+      path: "(required) The absolute or relative directory path to list."
+    }
+  },
+  //================
+  {
+    name: "agent_new_task" /* NEW_TASK */,
+    description: "Create a new task with a given context.",
+    params: {
+      context: "(required) The context of the new task."
+    },
+    example: `## Example: Creating a new task
+<${"agent_new_task" /* NEW_TASK */}>
+<context>
+1. Current Work:
+   [Detailed description]
+
+2. Key Technical Concepts:
+   - [Concept 1]
+   - [Concept 2]
+   - [...]
+
+3. Relevant Files and Code:
+   - [File Name 1]
+      - [Summary of why this file is important]
+      - [Summary of the changes made to this file, if any]
+      - [Important Code Snippet]
+   - [File Name 2]
+      - [Important Code Snippet]
+   - [...]
+
+4. Problem Solving:
+   [Detailed description]
+
+5. Pending Tasks and Next Steps:
+   - [Task 1 details & next steps]
+   - [Task 2 details & next steps]
+   - [...]
+</context>
+</${"agent_new_task" /* NEW_TASK */}>`
+  },
+  {
+    name: "agent_load_skill" /* LOAD_SKILL */,
+    description: "Load a skill to perform a task. important: skill_name is required. must use this tool to load the skill; do not use any other method to read it.",
+    params: {
+      skill_name: "(required) The name of the skill to load."
+    }
+  }
+];
+var toolUseNames = Object.values(AgentDefaultTool);
+var dynamicToolUseNamesByNamespace = /* @__PURE__ */ new Map();
+function setDynamicToolUseNames(namespace, names) {
+  dynamicToolUseNamesByNamespace.set(namespace, new Set(names.map((name) => name.trim()).filter(Boolean)));
+}
+function getToolUseNames() {
+  const defaults = [...toolUseNames];
+  const dynamic = Array.from(dynamicToolUseNamesByNamespace.values()).flatMap((set) => Array.from(set));
+  return Array.from(/* @__PURE__ */ new Set([...defaults, ...dynamic]));
+}
+var READ_ONLY_TOOLS = [
+  "agent_list_files" /* LIST_FILES */,
+  "agent_read_file" /* FILE_READ */,
+  "agent_search_files" /* SEARCH */,
+  "agent_list_code_definition_names" /* LIST_CODE_DEF */,
+  "agent_browser_action" /* BROWSER */,
+  "agent_ask_followup_question" /* ASK */,
+  "agent_web_search" /* WEB_SEARCH */,
+  "agent_web_fetch" /* WEB_FETCH */,
+  "agent_load_skill" /* LOAD_SKILL */,
+  "agent_use_subagents" /* USE_SUBAGENTS */
+];
+function parseAssistantMessageV2(assistantMessage, toolParamNames2) {
+  const contentBlocks = [];
+  let currentTextContentStart = 0;
+  let currentTextContent;
+  let currentToolUseStart = 0;
+  let currentToolUse;
+  let currentParamValueStart = 0;
+  let currentParamName;
+  const toolUseOpenTags = /* @__PURE__ */ new Map();
+  const toolParamOpenTags = /* @__PURE__ */ new Map();
+  for (const name of getToolUseNames()) {
+    toolUseOpenTags.set(`<${name}>`, name);
+  }
+  for (const name of toolParamNames2) {
+    toolParamOpenTags.set(`<${name}>`, name);
+  }
+  const len = assistantMessage.length;
+  for (let i = 0; i < len; i++) {
+    const currentCharIndex = i;
+    if (currentToolUse && currentParamName) {
+      const closeTag = `</${currentParamName}>`;
+      if (currentCharIndex >= closeTag.length - 1 && assistantMessage.startsWith(
+        closeTag,
+        currentCharIndex - closeTag.length + 1
+        // Start checking from potential start of tag
+      )) {
+        const value = assistantMessage.slice(
+          currentParamValueStart,
+          // Start after the opening tag
+          currentCharIndex - closeTag.length + 1
+          // End before the closing tag
+        ).trim();
+        currentToolUse.params[currentParamName] = value;
+        currentParamName = void 0;
+      } else {
+        continue;
+      }
+    }
+    if (currentToolUse && !currentParamName) {
+      let startedNewParam = false;
+      for (const [tag, paramName] of toolParamOpenTags.entries()) {
+        if (currentCharIndex >= tag.length - 1 && assistantMessage.startsWith(tag, currentCharIndex - tag.length + 1)) {
+          currentParamName = paramName;
+          currentParamValueStart = currentCharIndex + 1;
+          startedNewParam = true;
+          break;
+        }
+      }
+      if (startedNewParam) {
+        continue;
+      }
+      const toolCloseTag = `</${currentToolUse.name}>`;
+      if (currentCharIndex >= toolCloseTag.length - 1 && assistantMessage.startsWith(toolCloseTag, currentCharIndex - toolCloseTag.length + 1)) {
+        const toolContentSlice = assistantMessage.slice(
+          currentToolUseStart,
+          // From after the tool opening tag
+          currentCharIndex - toolCloseTag.length + 1
+          // To before the tool closing tag
+        );
+        const contentParamName = "content";
+        if (currentToolUse.name === "agent_write_to_file" /* FILE_NEW */ && toolContentSlice.includes(`<${contentParamName}>`)) {
+          const contentStartTag = `<${contentParamName}>`;
+          const contentEndTag = `</${contentParamName}>`;
+          const contentStart = toolContentSlice.indexOf(contentStartTag);
+          const contentEnd = toolContentSlice.lastIndexOf(contentEndTag);
+          if (contentStart !== -1 && contentEnd !== -1 && contentEnd > contentStart) {
+            const contentValue = toolContentSlice.slice(contentStart + contentStartTag.length, contentEnd).trim();
+            currentToolUse.params[contentParamName] = contentValue;
+          }
+        }
+        currentToolUse.partial = false;
+        contentBlocks.push(currentToolUse);
+        currentToolUse = void 0;
+        currentTextContentStart = currentCharIndex + 1;
+        continue;
+      }
+      continue;
+    }
+    if (!currentToolUse) {
+      let startedNewTool = false;
+      for (const [tag, toolName] of toolUseOpenTags.entries()) {
+        if (currentCharIndex >= tag.length - 1 && assistantMessage.startsWith(tag, currentCharIndex - tag.length + 1)) {
+          if (currentTextContent) {
+            currentTextContent.content = assistantMessage.slice(
+              currentTextContentStart,
+              // From where text started
+              currentCharIndex - tag.length + 1
+              // To before the tool tag starts
+            ).trim();
+            currentTextContent.partial = false;
+            if (currentTextContent.content.length > 0) {
+              contentBlocks.push(currentTextContent);
+            }
+            currentTextContent = void 0;
+          } else {
+            const potentialText = assistantMessage.slice(
+              currentTextContentStart,
+              // From where text *might* have started
+              currentCharIndex - tag.length + 1
+              // To before the tool tag starts
+            ).trim();
+            if (potentialText.length > 0) {
+              contentBlocks.push({
+                type: "text",
+                content: potentialText,
+                partial: false
+              });
+            }
+          }
+          currentToolUse = {
+            type: "tool_use",
+            name: toolName,
+            params: {},
+            partial: true,
+            // Assume partial until closing tag is found
+            call_id: nanoid(8),
+            isNativeToolCall: false
+          };
+          currentToolUseStart = currentCharIndex + 1;
+          startedNewTool = true;
+          break;
+        }
+      }
+      if (startedNewTool) {
+        continue;
+      }
+      if (!currentTextContent) {
+        currentTextContentStart = currentCharIndex;
+        currentTextContent = {
+          type: "text",
+          content: "",
+          // Will be determined by slicing at the end or when a tool starts
+          partial: true
+        };
+      }
+    }
+  }
+  if (currentToolUse && currentParamName) {
+    currentToolUse.params[currentParamName] = assistantMessage.slice(currentParamValueStart).trim();
+  }
+  if (currentToolUse) {
+    contentBlocks.push(currentToolUse);
+  } else if (currentTextContent) {
+    currentTextContent.content = assistantMessage.slice(currentTextContentStart).trim();
+    if (currentTextContent.content.length > 0) {
+      contentBlocks.push(currentTextContent);
+    }
+  }
+  return contentBlocks;
+}
+
+// src/parser/index.ts
+var toolParamNames = [
+  "command",
+  "requires_approval",
+  "path",
+  "absolutePath",
+  "content",
+  "diff",
+  "regex",
+  "file_pattern",
+  "recursive",
+  "action",
+  "url",
+  "coordinate",
+  "text",
+  "query",
+  "allowed_domains",
+  "blocked_domains",
+  "prompt",
+  "server_name",
+  "tool_name",
+  "arguments",
+  "uri",
+  "question",
+  "options",
+  "response",
+  "result",
+  "context",
+  "title",
+  "what_happened",
+  "steps_to_reproduce",
+  "api_request_output",
+  "additional_context",
+  "needs_more_exploration",
+  "task_progress",
+  "timeout",
+  "input",
+  "from_ref",
+  "to_ref",
+  "skill_name",
+  "prompt_1",
+  "prompt_2",
+  "prompt_3",
+  "prompt_4",
+  "prompt_5",
+  "start_line",
+  "end_line"
+];
+var AgentState = /* @__PURE__ */ ((AgentState2) => {
+  AgentState2["IDLE"] = "idle";
+  AgentState2["THINKING"] = "thinking";
+  AgentState2["WAITING_FOR_USER"] = "waiting_for_user";
+  AgentState2["FINISHED"] = "finished";
+  AgentState2["ERROR"] = "error";
+  return AgentState2;
+})(AgentState || {});
+var ClineAgent = class {
+  runtime;
+  api;
+  promptManager;
+  memory;
+  mcp;
+  state = "idle" /* IDLE */;
+  allToolParamNames = [...toolParamNames];
+  /** 循环计数器 */
+  loopCount = 0;
+  /** 最大循环次数 */
+  maxLoopCount;
+  skillDir;
+  customTools;
+  customToolNames;
+  allowDefaultTools;
+  customInstructions;
+  sysPrompt;
+  noUseTollSysPrompt;
+  // 简单的事件回调系统，供宿主环境注册以监听 Agent 内部事件
+  onStateChange;
+  onStreamChunk;
+  onToolCall;
+  constructor(options) {
+    this.runtime = options.runtime;
+    this.api = options.api;
+    this.promptManager = options.promptManager;
+    this.memory = options.memory;
+    this.mcp = options.mcp;
+    this.maxLoopCount = options.maxLoopCount ?? 150;
+    this.customTools = options.customTools || [];
+    this.allowDefaultTools = options.allowDefaultTools;
+    if (this.allowDefaultTools && !this.allowDefaultTools.includes("agent_attempt_completion" /* ATTEMPT */)) {
+      this.allowDefaultTools.push("agent_attempt_completion" /* ATTEMPT */);
+    }
+    this.customInstructions = options.customInstructions;
+    if (this.customTools.length > 0) {
+      const dynamicToolNames = /* @__PURE__ */ new Set();
+      const customToolParams = /* @__PURE__ */ new Set();
+      for (const customTool of this.customTools) {
+        dynamicToolNames.add(customTool.name);
+        if (customTool.params) {
+          for (const key in customTool.params) {
+            if (!Object.hasOwn(customTool.params, key)) continue;
+            customToolParams.add(key);
+          }
+        }
+      }
+      const defaultToolNames = Object.values(AgentDefaultTool);
+      const overlappingTools = Array.from(dynamicToolNames).filter((name) => defaultToolNames.includes(name));
+      if (overlappingTools.length > 0) {
+        throw new Error(`Custom tools and default tools have overlapping names: ${overlappingTools.join(", ")}`);
+      }
+      if (dynamicToolNames.size > 0) {
+        setDynamicToolUseNames("customUser", Array.from(dynamicToolNames));
+      }
+      if (customToolParams.size > 0) {
+        this.allToolParamNames = Array.from(/* @__PURE__ */ new Set([...this.allToolParamNames, ...Array.from(customToolParams)]));
+      }
+    }
+    this.customToolNames = new Set(this.customTools.map((t) => t.name));
+    this.skillDir = this.runtime.path.join(this.runtime.env.cwd(), ".agent/skills");
+  }
+  setState(newState) {
+    this.state = newState;
+    if (this.onStateChange) {
+      this.onStateChange(newState);
+    }
+  }
+  /**
+   * 获取当前 Agent 的系统提示词 
+   * 如果 force 为 true，则强制重新获取系统提示词
+   */
+  async getPrompt(force = false) {
+    if (!force && this.sysPrompt && this.noUseTollSysPrompt) {
+      return { sysPrompt: this.sysPrompt, noUseTollSysPrompt: this.noUseTollSysPrompt };
+    }
+    const context = {
+      cwd: this.runtime.env.cwd(),
+      os: this.runtime.env.osInfo(),
+      shell: this.runtime.env.shell(),
+      skills: await this.getSkills(),
+      customTools: this.customTools,
+      allowDefaultTools: this.allowDefaultTools,
+      customInstructions: this.customInstructions
+    };
+    this.sysPrompt = await this.promptManager.getSystemPrompt(context);
+    this.noUseTollSysPrompt = this.promptManager.getNoUseToolInstructions(context);
+    return { sysPrompt: this.sysPrompt, noUseTollSysPrompt: this.noUseTollSysPrompt };
+  }
+  /**
+   * 启动一个新的任务
+   */
+  async startTask(taskDescription) {
+    this.setState("thinking" /* THINKING */);
+    try {
+      await this.memory.clear();
+      this.loopCount = 0;
+      await this.memory.appendMessage({
+        role: "user",
+        content: taskDescription
+      });
+      await this.loop();
+    } catch (err) {
+      this.setState("error" /* ERROR */);
+      throw err;
+    }
+  }
+  async getSkills() {
+    const skillDir = this.skillDir;
+    const skillList = [];
+    if (!this.runtime.fs.fileExists(skillDir)) {
+      return skillList;
+    }
+    const files = await this.runtime.fs.readDir(skillDir);
+    const skills = files.filter((item) => item.isDirectory()).map((item) => item.name);
+    if (skills.length === 0) {
+      return [];
+    }
+    for (const skill of skills) {
+      try {
+        const skillPath = this.runtime.path.join(skillDir, skill);
+        const files2 = await this.runtime.fs.readDir(skillPath);
+        const skillFile = files2.map((item) => item.isFile()).find((f) => f.toLowerCase() === "skill.md");
+        if (skillFile) {
+          const mdPath = this.runtime.path.join(skillPath, skillFile);
+          const mdContent = await this.runtime.fs.readFile(mdPath);
+          const parsed = matter(mdContent);
+          if (parsed.data && parsed.data.description) {
+            let description = String(parsed.data.description).trim();
+            description = description.replace(/\s+/g, " ").trim();
+            if (description) {
+              skillList.push({
+                name: skill,
+                description
+              });
+            }
+          }
+        }
+      } catch (e) {
+        return skillList;
+      }
+    }
+  }
+  /**
+   * 核心任务循环
+   */
+  async loop() {
+    const { sysPrompt, noUseTollSysPrompt } = await this.getPrompt(true);
+    const { customTools, customToolNames } = this;
+    while (this.state === "thinking" /* THINKING */) {
+      this.loopCount++;
+      if (this.loopCount > this.maxLoopCount) {
+        await this.memory.appendMessage({
+          role: "user",
+          content: `[ERROR] You have exceeded the maximum loop limit of ${this.maxLoopCount} times. Please immediately call the agent_attempt_completion tool to return the final result. If you have pending user-specified tools to execute, you may run them first before calling agent_attempt_completion.`
+        });
+      }
+      const history = await this.memory.getHistory();
+      const stream = this.api.createMessage(sysPrompt, history);
+      let fullResponseText = "";
+      for await (const chunk of stream) {
+        if (chunk.type === "text" && chunk.text) {
+          fullResponseText += chunk.text;
+        }
+        if (this.onStreamChunk) {
+          this.onStreamChunk(chunk);
+        }
+      }
+      await this.memory.appendMessage({
+        role: "assistant",
+        content: fullResponseText
+      });
+      const parsedBlocks = parseAssistantMessageV2(fullResponseText, this.allToolParamNames);
+      const toolUses = parsedBlocks.filter((b) => b.type === "tool_use");
+      if (toolUses.length === 0) {
+        await this.memory.appendMessage({
+          role: "user",
+          content: noUseTollSysPrompt
+        });
+      } else {
+        const toolResults = [];
+        for (const tool of toolUses) {
+          if (this.onToolCall) {
+            const hookResult = await this.onToolCall(tool);
+            if (hookResult) {
+              toolResults.push({ tool, result: hookResult });
+              continue;
+            }
+          }
+          if (customToolNames.has(tool.name)) {
+            const customTool = customTools.find((t) => t.name === tool.name);
+            if (customTool.onCall) {
+              try {
+                const res = await customTool.onCall(tool.params);
+                toolResults.push({ tool, result: res });
+              } catch (error) {
+                toolResults.push({ tool, result: `Error: ${error.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: `Error: Custom tool "${tool.name}" does not have an onCall method.` });
+            }
+            continue;
+          }
+          if (tool.name === "agent_attempt_completion" /* ATTEMPT */) {
+            toolResults.push({ tool, result: "Task marked as completed." });
+            this.setState("finished" /* FINISHED */);
+            break;
+          } else if (tool.name === "agent_read_file" /* FILE_READ */) {
+            const path = tool.params.path;
+            if (path) {
+              try {
+                const content = await this.runtime.fs.readFile(path);
+                toolResults.push({ tool, result: content });
+              } catch (error) {
+                toolResults.push({ tool, result: `Error: ${error.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: "Error: No path provided." });
+            }
+          } else if (tool.name === "agent_execute_command" /* BASH */) {
+            const cmd = tool.params.command;
+            if (cmd) {
+              const result = await this.runtime.terminal.execCommand(cmd);
+              toolResults.push({ tool, result: `STDOUT: ${result.stdout}
+STDERR: ${result.stderr}` });
+            }
+          } else if (tool.name === "agent_write_to_file" /* FILE_NEW */) {
+            const path = tool.params.path;
+            const content = tool.params.content;
+            if (path && content !== void 0) {
+              try {
+                await this.runtime.fs.writeFile(path, content);
+                toolResults.push({ tool, result: `Successfully wrote to ${path}` });
+              } catch (error) {
+                toolResults.push({ tool, result: `Error: ${error.message}` });
+              }
+            }
+          } else if (tool.name === "agent_list_files" /* LIST_FILES */) {
+            const path = tool.params.path || this.runtime.env.cwd();
+            try {
+              const files = await this.runtime.fs.readDir(path);
+              toolResults.push({ tool, result: files.map((f) => f.name + (f.isDirectory() ? "/" : "")).join("\n") });
+            } catch (e) {
+              toolResults.push({ tool, result: `Error: ${e.message}` });
+            }
+          } else if (tool.name === "agent_replace_in_file" /* FILE_EDIT */) {
+            const path = tool.params.path;
+            const diff = tool.params.diff;
+            if (path && diff) {
+              try {
+                const content = await this.runtime.fs.readFile(path);
+                const newContent = this.applyDiff(content, diff);
+                await this.runtime.fs.writeFile(path, newContent);
+                toolResults.push({ tool, result: `Successfully replaced content in ${path}` });
+              } catch (e) {
+                toolResults.push({ tool, result: `Error: ${e.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: "Error: Missing path or diff." });
+            }
+          } else if (tool.name === "agent_delete_file" /* FILE_DELETE */) {
+            const path = tool.params.path;
+            if (path) {
+              try {
+                await this.runtime.fs.deleteFile(path);
+                toolResults.push({ tool, result: `Successfully deleted ${path}` });
+              } catch (e) {
+                toolResults.push({ tool, result: `Error: ${e.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: "Error: Missing path." });
+            }
+          } else if (tool.name === "agent_delete_directory" /* DIR_DELETE */) {
+            const path = tool.params.path;
+            if (path) {
+              try {
+                await this.runtime.fs.deleteDirectory(path);
+                toolResults.push({ tool, result: `Successfully deleted ${path}` });
+              } catch (e) {
+                toolResults.push({ tool, result: `Error: ${e.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: "Error: Missing path." });
+            }
+          } else if (tool.name === "agent_ask_followup_question" /* ASK */) {
+            const question = tool.params.question;
+            toolResults.push({ tool, result: `Asking user: ${question}` });
+            this.setState("waiting_for_user" /* WAITING_FOR_USER */);
+            break;
+          } else if (tool.name === "agent_search_files" /* SEARCH */) {
+            const path = tool.params.path || this.runtime.env.cwd();
+            const regexStr = tool.params.regex;
+            const filePattern = tool.params.file_pattern;
+            if (regexStr && this.runtime.fs.searchFiles) {
+              try {
+                const result = await this.runtime.fs.searchFiles(path, regexStr, filePattern);
+                toolResults.push({ tool, result: `${result}` });
+              } catch (e) {
+                toolResults.push({ tool, result: `Error: ${e.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: `Error: searchFiles not supported by runtime or missing regex.` });
+            }
+          } else if (tool.name === "agent_use_mcp_tool" /* MCP_USE */) {
+            const serverName = tool.params.server_name;
+            const toolName = tool.params.tool_name;
+            const args = tool.params.arguments;
+            if (this.mcp && serverName && toolName) {
+              try {
+                let parsedArgs = args;
+                if (typeof args === "string") {
+                  parsedArgs = JSON.parse(args);
+                }
+                const result = await this.mcp.callTool(serverName, toolName, parsedArgs);
+                if (result.isError) {
+                  toolResults.push({ tool, result: `Error executing MCP tool: ${JSON.stringify(result.content)}` });
+                } else {
+                  toolResults.push({ tool, result: `${JSON.stringify(result.content)}` });
+                }
+              } catch (e) {
+                toolResults.push({ tool, result: `Error: ${e.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: `Error: MCP Manager not available or missing parameters.` });
+            }
+          } else if (tool.name === "agent_access_mcp_resource" /* MCP_ACCESS */) {
+            const serverName = tool.params.server_name;
+            const uri = tool.params.uri;
+            if (this.mcp && this.mcp.readResource && serverName && uri) {
+              try {
+                const result = await this.mcp.readResource(serverName, uri);
+                toolResults.push({ tool, result: `${JSON.stringify(result)}` });
+              } catch (e) {
+                toolResults.push({ tool, result: `Error: ${e.message}` });
+              }
+            } else {
+              toolResults.push({ tool, result: `Error: MCP Manager not available, readResource not implemented, or missing parameters.` });
+            }
+          } else if (tool.name === "agent_load_mcp_documentation" /* MCP_DOCS */) {
+            const docs = `MCP (Model Context Protocol) is used to connect to external tools/resources. To build one, typically you create an HTTP/stdio server responding to MCP defined JSON-RPC messages...`;
+            toolResults.push({ tool, result: docs });
+          } else if (tool.name === "agent_list_code_definition_names" /* LIST_CODE_DEF */) {
+            const path = tool.params.path || this.runtime.env.cwd();
+            try {
+              const result = await this.runtime.fs.searchFiles?.(path, "^(class|function|const|let|var|export|interface|type)\\s+\\w+", "*.ts|*.js");
+              toolResults.push({ tool, result: `${result ? result : "No definitions found or searchFiles not supported."}` });
+            } catch (e) {
+              toolResults.push({ tool, result: `Error: ${e.message}` });
+            }
+          } else if (tool.name === "agent_web_fetch" /* WEB_FETCH */) {
+            const url = tool.params.url;
+            if (url) {
+              try {
+                const res = await fetch(url);
+                const text = await res.text();
+                toolResults.push({ tool, result: text.substring(0, 3e3) });
+              } catch (e) {
+                toolResults.push({ tool, result: `Error: ${e.message}` });
+              }
+            }
+          } else if (tool.name === "agent_focus_chain" /* TODO */) {
+            toolResults.push({ tool, result: `Focus chain updated successfully.` });
+          } else if (tool.name === "agent_plan_mode_respond" /* PLAN_MODE */ || tool.name === "agent_act_mode_respond" /* ACT_MODE */) {
+            toolResults.push({ tool, result: `Mode switch acknowledged.` });
+          } else if (tool.name === "agent_new_rule" /* NEW_RULE */) {
+            toolResults.push({ tool, result: `Rule recorded in current context.` });
+          } else if (tool.name === "agent_new_task" /* NEW_TASK */) {
+            toolResults.push({ tool, result: `New task request received. Terminating current task.` });
+            this.setState("finished" /* FINISHED */);
+            break;
+          } else if (tool.name === "agent_load_skill" /* LOAD_SKILL */) {
+            const skillName = tool.params.skill_name || tool.params.skill;
+            if (!skillName) {
+              toolResults.push({ tool, result: `"Error: Missing required parameter 'skill_name'. Please provide the name of the skill to activate."` });
+            } else {
+              const skillDir = this.skillDir;
+              const skillFilePath = this.runtime.path.join(skillDir, skillName, "SKILL.md");
+              try {
+                const fileExists = await this.runtime.fs.fileExists(skillFilePath);
+                if (!fileExists) {
+                  toolResults.push({ tool, result: `Error: Skill "${skillName}" not found at ${skillFilePath}.` });
+                } else {
+                  const content = await this.runtime.fs.readFile(skillFilePath);
+                  toolResults.push({
+                    tool,
+                    result: `# Skill "${skillName}" is now active
+
+${content}
+
+---
+IMPORTANT: The skill is now loaded. Do NOT call agent_load_skill again for this task. Simply follow the instructions above to complete the user's request.`
+                  });
+                }
+              } catch (err) {
+                toolResults.push({ tool, result: `Error loading skill "${skillName}": ${err.message}` });
+              }
+            }
+          } else if (tool.name === "agent_browser_action" /* BROWSER */ || tool.name === "agent_web_search" /* WEB_SEARCH */ || tool.name === "agent_apply_patch" /* APPLY_PATCH */) {
+            toolResults.push({ tool, result: `This tool requires specific host integration. If you see this, the host environment has not implemented it yet.` });
+          } else if (tool.name === "agent_condense" /* CONDENSE */ || tool.name === "agent_summarize_task" /* SUMMARIZE_TASK */ || tool.name === "agent_report_bug" /* REPORT_BUG */ || tool.name === "agent_generate_explanation" /* GENERATE_EXPLANATION */) {
+            toolResults.push({ tool, result: `Action logged successfully.` });
+          } else {
+            toolResults.push({ tool, result: `Executed by host or unsupported.` });
+          }
+        }
+        if (this.state === "thinking" /* THINKING */ && toolResults.length > 0) {
+          const toolResultsContext = toolResults.map((tr) => `<${TOOL_RESULT_BLOCK} tool_name="${tr.tool.name}">
+${typeof tr.result === "string" ? tr.result.trim() : JSON.stringify(tr.result)}
+</${TOOL_RESULT_BLOCK}>`).join("\n\n");
+          if (this.onStreamChunk) {
+            this.onStreamChunk({ type: "text", text: toolResultsContext });
+          }
+          await this.memory.appendMessage({
+            role: "user",
+            content: toolResultsContext
+          });
+        }
+      }
+    }
+  }
+  /**
+   * 简单的 Diff 解析与替换辅助方法
+   */
+  applyDiff(content, diff) {
+    const regex = /-------\s*SEARCH\r?\n(.*?)\r?\n=======\r?\n(.*?)\r?\n\+\+\+\+\+\+\+\s*REPLACE/gs;
+    let newContent = content;
+    let match;
+    let matchCount = 0;
+    while ((match = regex.exec(diff)) !== null) {
+      matchCount++;
+      const searchBlock = match[1];
+      const replaceBlock = match[2];
+      const idx = newContent.indexOf(searchBlock);
+      if (idx !== -1) {
+        newContent = newContent.substring(0, idx) + replaceBlock + newContent.substring(idx + searchBlock.length);
+      } else {
+        throw new Error(`Search block not found in file:
+${searchBlock.substring(0, 100)}...`);
+      }
+    }
+    if (matchCount === 0) {
+      throw new Error(`No valid SEARCH/REPLACE blocks found in the diff.`);
+    }
+    return newContent;
+  }
+  /**
+   * 恢复被中断的循环（例如等待用户输入/确认后继续）
+   */
+  async resume(userInput) {
+    if (userInput) {
+      await this.memory.appendMessage({
+        role: "user",
+        content: userInput
+      });
+    }
+    this.setState("thinking" /* THINKING */);
+    await this.loop();
+  }
+  async appendHistory(history) {
+    for (const message of history) {
+      await this.memory.appendMessage(message);
+    }
+  }
+  async getHistory() {
+    return this.memory.getHistory();
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+globalThis.AI_SDK_LOG_WARNINGS = false;
+
+export { AgentDefaultTool, AgentState, ClineAgent, READ_ONLY_TOOLS, TOOL_RESULT_BLOCK, VERSION, defaultTools, getToolUseNames, parseAssistantMessageV2, setDynamicToolUseNames, toolParamNames, toolUseNames };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map