@amical/aiagent-sdk 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,45 +1,11 @@
 'use strict';
 
 var nanoid = require('nanoid');
-var ai = require('ai');
-var openai = require('@ai-sdk/openai');
-var difyAiProvider = require('dify-ai-provider');
 var matter = require('gray-matter');
-var fs2 = require('fs/promises');
-var path2 = require('path');
-var os = require('os');
-var child_process = require('child_process');
-var util = require('util');
-require('@modelcontextprotocol/sdk/client/index.js');
-require('@modelcontextprotocol/sdk/client/stdio.js');
-var memfs = require('memfs');
-var path3 = require('path-browserify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
 var matter__default = /*#__PURE__*/_interopDefault(matter);
-var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
-var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
-var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var path3__default = /*#__PURE__*/_interopDefault(path3);
 
 // src/shared/tools.ts
 var AgentDefaultTool = /* @__PURE__ */ ((AgentDefaultTool2) => {
@@ -505,728 +471,6 @@ var toolParamNames = [
   "start_line",
   "end_line"
 ];
-
-// src/prompt/NodePromptManager.ts
-var NodePromptManager = class {
-  async getSystemPrompt(context) {
-    let prompt = `# Role
-you are a highly skilled software engineer AI running in a Node.js/Desktop environment.
-You have FULL access to the local file system and can execute arbitrary shell commands on the user's machine.
-
-# Capabilities & Rules
-1. **File System**: You can read, write, create, and delete files/directories anywhere accessible to the user process. Always use absolute paths or paths relative to the Current Working Directory.
-2. **Terminal**: You can execute system commands (e.g., git, npm, python, file manipulation) directly.
-3. **Context**: You are running on a real machine, meaning you have access to real environment variables, local servers (localhost), and local network.
-4. **Destructive Actions**: Be extremely careful when executing commands that modify system state or delete files. Double-check paths and commands before execution.
-5. **Step-by-step**: Use tools one at a time. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
-6. **Verification**: Always verify the result of your actions (e.g., run tests, compile code, list directories) before proceeding to the next step or completing the task.
-7. **Communication**: Be concise and technical. Formulate your output strictly according to the tools' XML specification.
-
-TOOL USE
-
-You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
-
-# Tool Use Formatting
-
-Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-
-<tool_name>
-<parameter1_name>value1</parameter1_name>
-<parameter2_name>value2</parameter2_name>
-...
-</tool_name>
-
-For example:
-
-<agent_read_file>
-<path>src/main.js</path>
-<task_progress>
-Checklist here (optional)
-</task_progress>
-</agent_read_file>
-
-Always adhere to this format for the tool use to ensure proper parsing and execution.
-`;
-    const skillsPrompt = await this.getSkillsPrompt(context.skills);
-    if (skillsPrompt) {
-      prompt += `
-${skillsPrompt}
-`;
-    }
-    prompt += `
-${this.getToolInstructions(context)}
-`;
-    const envPrompt = this.getEnvironmentInfoPrompt(context);
-    if (envPrompt) {
-      prompt += `
-${envPrompt}
-`;
-    }
-    if (context.customInstructions) {
-      prompt += `
-# User Custom Instructions
-${context.customInstructions}
-`;
-    }
-    return prompt;
-  }
-  getEnvironmentInfoPrompt(context) {
-    let environmentPrompt = `<environment_details>
-  # Environment Info
-- **Current Working Directory**: \`${context.cwd}\`
-- **Operating System**: \`${context.os}\`
-`;
-    if (context.shell) {
-      environmentPrompt += `- **Current Shell**: \`${context.shell}\`
-`;
-    }
-    return environmentPrompt + `
-</environment_details>`;
-  }
-  async getSkillsPrompt(skills) {
-    if (!skills || skills.length === 0) return "";
-    try {
-      let prompt = `# Available Skills
-`;
-      prompt += `You have access to the following skills. You can use the \`agent_load_skill\` tool to load any of them when needed.
-`;
-      for (const skill of skills) {
-        if (skill && skill.name && skill.description) {
-          prompt += `- **${skill.name}**: ${skill.description}
-`;
-        }
-      }
-      return prompt;
-    } catch (e) {
-      return "";
-    }
-  }
-  getToolInstructions(context) {
-    const allowDefaultTools = context.allowDefaultTools;
-    const customTools = context.customTools || [];
-    let useDefaultTools = [...defaultTools];
-    if (allowDefaultTools) {
-      useDefaultTools = defaultTools.filter((tool) => allowDefaultTools.includes(tool.name));
-    }
-    return `# Available Tools
-You can use the following tools by formatting your output as XML blocks. Only use ONE tool per message, and ALWAYS wait for the user's response with the execution result before proceeding.
-
-${[...useDefaultTools, ...customTools].map((tool) => {
-      return `### ${tool.name}
-Description: ${tool.description}
-Parameters: 
-${Object.entries(tool.params).map(([name, description]) => `- ${name}: ${description.replaceAll("${context.cwd}", context.cwd)}`).join("\n")}
-- task_progress: (optional) A checklist showing task progress after this tool use is completed. The task_progress parameter must be included as a separate parameter inside of the parent tool call, it must be separate from other parameters such as content, arguments, etc. (See 'UPDATING TASK PROGRESS' section for more details)
-Usage: 
-<${tool.name}>
-${Object.entries(tool.params).map(([name, description]) => `<${name}>${description.replaceAll("${context.cwd}", context.cwd)}</${name}>`).join("\n")}
-<task_progress>Checklist here (optional)</task_progress>
-</${tool.name}>
-`;
-    }).join("\n")}
-
-# Tool Use Examples
-${useDefaultTools.filter((item) => Boolean(item.example)).map((item) => item.example).join("\n")}}
-
-# Tool Use Guidelines
-
-1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
-2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
-3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
-4. Formulate your tool use using the XML format specified for each tool.
-5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
-  - Information about whether the tool succeeded or failed, along with any reasons for failure.
-  - Linter errors that may have arisen due to the changes you made, which you'll need to address.
-  - New terminal output in reaction to the changes, which you may need to consider or act upon.
-  - Any other relevant feedback or information related to the tool use.
-6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
-
-It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
-1. Confirm the success of each step before proceeding.
-2. Address any issues or errors that arise immediately.
-3. Adapt your approach based on new information or unexpected results.
-4. Ensure that each action builds correctly on the previous ones.
-
-By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.
-
-====
-
-UPDATING TASK PROGRESS
-
-You can track and communicate your progress on the overall task using the task_progress parameter supported by every tool call. Using task_progress ensures you remain on task, and stay focused on completing the user's objective. This parameter can be used in any mode, and with any tool call.
-
-- When switching from PLAN MODE to ACT MODE, you must create a comprehensive todo list for the task using the task_progress parameter
-- Todo list updates should be done silently using the task_progress parameter - do not announce these updates to the user
-- Use standard Markdown checklist format: "- [ ]" for incomplete items and "- [x]" for completed items
-- Keep items focused on meaningful progress milestones rather than minor technical details. The checklist should not be so granular that minor implementation details clutter the progress tracking.
-- For simple tasks, short checklists with even a single item are acceptable. For complex tasks, avoid making the checklist too long or verbose.
-- If you are creating this checklist for the first time, and the tool use completes the first step in the checklist, make sure to mark it as completed in your task_progress parameter.
-- Provide the whole checklist of steps you intend to complete in the task, and keep the checkboxes updated as you make progress. It's okay to rewrite this checklist as needed if it becomes invalid due to scope changes or new information.
-- If a checklist is being used, be sure to update it any time a step has been completed.
-- The system will automatically include todo list context in your prompts when appropriate - these reminders are important.
-
-Example:
-<agent_execute_command>
-<command>npm install react</command>
-<requires_approval>false</requires_approval>
-<task_progress>
-- [x] Set up project structure
-- [x] Install dependencies
-- [ ] Create components
-- [ ] Test application
-</task_progress>
-</agent_execute_command>
-
-====
-
-EDITING FILES
-
-You have access to two tools for working with files: **agent_write_to_file** and **agent_replace_in_file**. Understanding their roles and selecting the right one for the job will help ensure efficient and accurate modifications.
-
-# agent_write_to_file
-
-## Purpose
-
-- Create a new file, or overwrite the entire contents of an existing file.
-
-## When to Use
-
-- Initial file creation, such as when scaffolding a new project.  
-- Overwriting large boilerplate files where you want to replace the entire content at once.
-- When the complexity or number of changes would make agent_replace_in_file unwieldy or error-prone.
-- When you need to completely restructure a file's content or change its fundamental organization.
-
-## Important Considerations
-
-- Using agent_write_to_file requires providing the file's complete final content.  
-- If you only need to make small changes to an existing file, consider using agent_replace_in_file instead to avoid unnecessarily rewriting the entire file.
-- While agent_write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
-
-# agent_replace_in_file
-
-## Purpose
-
-- Make targeted edits to specific parts of an existing file without overwriting the entire file.
-
-## When to Use
-
-- Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
-- Targeted improvements where only specific portions of the file's content needs to be altered.
-- Especially useful for long files where much of the file will remain unchanged.
-
-## Advantages
-
-- More efficient for minor edits, since you don't need to supply the entire file content.  
-- Reduces the chance of errors that can occur when overwriting large files.
-
-# Choosing the Appropriate Tool
-
-- **Default to agent_replace_in_file** for most changes. It's the safer, more precise option that minimizes potential issues.
-- **Use agent_write_to_file** when:
-  - Creating new files
-  - The changes are so extensive that using agent_replace_in_file would be more complex or risky
-  - You need to completely reorganize or restructure a file
-  - The file is relatively small and the changes affect most of its content
-  - You're generating boilerplate or template files
-
-# Auto-formatting Considerations
-
-- After using either agent_write_to_file or agent_replace_in_file, the user's editor may automatically format the file
-- This auto-formatting may modify the file contents, for example:
-  - Breaking single lines into multiple lines
-  - Adjusting indentation to match project style (e.g. 2 spaces vs 4 spaces vs tabs)
-  - Converting single quotes to double quotes (or vice versa based on project preferences)
-  - Organizing imports (e.g. sorting, grouping by type)
-  - Adding/removing trailing commas in objects and arrays
-  - Enforcing consistent brace style (e.g. same-line vs new-line)
-  - Standardizing semicolon usage (adding or removing based on style)
-- The agent_write_to_file and agent_replace_in_file tool responses will include the final state of the file after any auto-formatting
-- Use this final state as your reference point for any subsequent edits. This is ESPECIALLY important when crafting SEARCH blocks for replace_in_file which require the content to match what's in the file exactly.
-
-# Workflow Tips
-
-1. Before editing, assess the scope of your changes and decide which tool to use.
-2. For targeted edits, apply agent_replace_in_file with carefully crafted SEARCH/REPLACE blocks. If you need multiple changes, you can stack multiple SEARCH/REPLACE blocks within a single agent_replace_in_file call.
-3. IMPORTANT: When you determine that you need to make several changes to the same file, prefer to use a single replace_in_file call with multiple SEARCH/REPLACE blocks. DO NOT prefer to make multiple successive replace_in_file calls for the same file. For example, if you were to add a component to a file, you would use a single replace_in_file call with a SEARCH/REPLACE block to add the import statement and another SEARCH/REPLACE block to add the component usage, rather than making one replace_in_file call for the import statement and then another separate replace_in_file call for the component usage.
-4. For major overhauls or initial file creation, rely on agent_write_to_file.
-5. Once the file has been edited with either agent_write_to_file or agent_replace_in_file, the system will provide you with the final state of the modified file. Use this updated content as the reference point for any subsequent SEARCH/REPLACE operations, since it reflects any auto-formatting or user-applied changes.  
-By thoughtfully selecting between agent_write_to_file and agent_replace_in_file, you can make your file editing process smoother, safer, and more efficient.
-
-====
-`;
-  }
-  getNoUseToolInstructions(context) {
-    return `[ERROR] You did not use a tool in your previous response! Please retry with a tool use.
-
-# Reminder: Instructions for Tool Use
-Tool uses are formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-<tool_name>
-<parameter1_name>value1</parameter1_name>
-<parameter2_name>value2</parameter2_name>
-...
-</tool_name>
-For example:
-<agent_attempt_completion>
-<result>
-I have completed the task...
-</result>
-</agent_attempt_completion>
-Always adhere to this format for all tool uses to ensure proper parsing and execution.
-
-# Next Steps
-
-If you have completed the user's task, use the attempt_completion tool. 
-If you require additional information from the user, use the ask_followup_question tool. 
-Otherwise, if you have not completed the task and do not need additional information, then proceed with the next step of the task. 
-(This is an automated message, so do not respond to it conversationally.)
-${this?.getEnvironmentInfoPrompt?.(context)}`;
-  }
-};
-
-// src/prompt/WebPromptManager.ts
-var WebPromptManager = class {
-  async getSystemPrompt(context) {
-    let prompt = `# Role
-you are a highly skilled software engineer AI running in a Node.js/Desktop environment.
-You have FULL access to the local file system and can execute arbitrary shell commands on the user's machine.
-
-# Capabilities & Rules
-1. **File System**: You can read, write, create, and delete files/directories anywhere accessible to the user process. Always use absolute paths or paths relative to the Current Working Directory.
-2. **Terminal**: You can execute system commands (e.g., git, npm, python, file manipulation) directly.
-3. **Context**: You are running on a real machine, meaning you have access to real environment variables, local servers (localhost), and local network.
-4. **Destructive Actions**: Be extremely careful when executing commands that modify system state or delete files. Double-check paths and commands before execution.
-5. **Step-by-step**: Use tools one at a time. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
-6. **Verification**: Always verify the result of your actions (e.g., run tests, compile code, list directories) before proceeding to the next step or completing the task.
-7. **Communication**: Be concise and technical. Formulate your output strictly according to the tools' XML specification.
-
-TOOL USE
-
-You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
-
-# Tool Use Formatting
-
-Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-
-<tool_name>
-<parameter1_name>value1</parameter1_name>
-<parameter2_name>value2</parameter2_name>
-...
-</tool_name>
-
-For example:
-
-<agent_read_file>
-<path>src/main.js</path>
-<task_progress>
-Checklist here (optional)
-</task_progress>
-</agent_read_file>
-
-Always adhere to this format for the tool use to ensure proper parsing and execution.
-`;
-    const skillsPrompt = await this.getSkillsPrompt(context.skills);
-    if (skillsPrompt) {
-      prompt += `
-${skillsPrompt}
-`;
-    }
-    prompt += `
-${this.getToolInstructions(context)}
-`;
-    const envPrompt = this.getEnvironmentInfoPrompt(context);
-    if (envPrompt) {
-      prompt += `
-${envPrompt}
-`;
-    }
-    if (context.customInstructions) {
-      prompt += `
-# User Custom Instructions
-${context.customInstructions}
-`;
-    }
-    return prompt;
-  }
-  getEnvironmentInfoPrompt(context) {
-    let environmentPrompt = `<environment_details>
-  # Environment Info
-- **Current Working Directory**: \`${context.cwd}\`
-- **Operating System**: \`${context.os}\`
-`;
-    if (context.shell) {
-      environmentPrompt += `- **Current Shell**: \`${context.shell}\`
-`;
-    }
-    return environmentPrompt + `
-</environment_details>`;
-  }
-  async getSkillsPrompt(skills) {
-    if (!skills || skills.length === 0) return "";
-    try {
-      let prompt = `# Available Skills
-`;
-      prompt += `You have access to the following skills. You can use the \`agent_load_skill\` tool to load any of them when needed.
-`;
-      for (const skill of skills) {
-        if (skill && skill.name && skill.description) {
-          prompt += `- **${skill.name}**: ${skill.description}
-`;
-        }
-      }
-      return prompt;
-    } catch (e) {
-      return "";
-    }
-  }
-  getToolInstructions(context) {
-    const allowDefaultTools = context.allowDefaultTools;
-    const customTools = context.customTools || [];
-    let useDefaultTools = [...defaultTools];
-    if (allowDefaultTools) {
-      useDefaultTools = defaultTools.filter((tool) => allowDefaultTools.includes(tool.name));
-    }
-    return `# Available Tools
-You can use the following tools by formatting your output as XML blocks. Only use ONE tool per message, and ALWAYS wait for the user's response with the execution result before proceeding.
-
-${[...useDefaultTools, ...customTools].map((tool) => {
-      return `### ${tool.name}
-Description: ${tool.description}
-Parameters: 
-${Object.entries(tool.params).map(([name, description]) => `- ${name}: ${description.replaceAll("${context.cwd}", context.cwd)}`).join("\n")}
-- task_progress: (optional) A checklist showing task progress after this tool use is completed. The task_progress parameter must be included as a separate parameter inside of the parent tool call, it must be separate from other parameters such as content, arguments, etc. (See 'UPDATING TASK PROGRESS' section for more details)
-Usage: 
-<${tool.name}>
-${Object.entries(tool.params).map(([name, description]) => `<${name}>${description.replaceAll("${context.cwd}", context.cwd)}</${name}>`).join("\n")}
-<task_progress>Checklist here (optional)</task_progress>
-</${tool.name}>
-`;
-    }).join("\n")}
-
-# Tool Use Examples
-${useDefaultTools.filter((item) => Boolean(item.example)).map((item) => item.example).join("\n")}}
-
-# Tool Use Guidelines
-
-1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
-2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
-3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
-4. Formulate your tool use using the XML format specified for each tool.
-5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
-  - Information about whether the tool succeeded or failed, along with any reasons for failure.
-  - Linter errors that may have arisen due to the changes you made, which you'll need to address.
-  - New terminal output in reaction to the changes, which you may need to consider or act upon.
-  - Any other relevant feedback or information related to the tool use.
-6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
-
-It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
-1. Confirm the success of each step before proceeding.
-2. Address any issues or errors that arise immediately.
-3. Adapt your approach based on new information or unexpected results.
-4. Ensure that each action builds correctly on the previous ones.
-
-By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.
-
-====
-
-UPDATING TASK PROGRESS
-
-You can track and communicate your progress on the overall task using the task_progress parameter supported by every tool call. Using task_progress ensures you remain on task, and stay focused on completing the user's objective. This parameter can be used in any mode, and with any tool call.
-
-- When switching from PLAN MODE to ACT MODE, you must create a comprehensive todo list for the task using the task_progress parameter
-- Todo list updates should be done silently using the task_progress parameter - do not announce these updates to the user
-- Use standard Markdown checklist format: "- [ ]" for incomplete items and "- [x]" for completed items
-- Keep items focused on meaningful progress milestones rather than minor technical details. The checklist should not be so granular that minor implementation details clutter the progress tracking.
-- For simple tasks, short checklists with even a single item are acceptable. For complex tasks, avoid making the checklist too long or verbose.
-- If you are creating this checklist for the first time, and the tool use completes the first step in the checklist, make sure to mark it as completed in your task_progress parameter.
-- Provide the whole checklist of steps you intend to complete in the task, and keep the checkboxes updated as you make progress. It's okay to rewrite this checklist as needed if it becomes invalid due to scope changes or new information.
-- If a checklist is being used, be sure to update it any time a step has been completed.
-- The system will automatically include todo list context in your prompts when appropriate - these reminders are important.
-
-Example:
-<agent_execute_command>
-<command>npm install react</command>
-<requires_approval>false</requires_approval>
-<task_progress>
-- [x] Set up project structure
-- [x] Install dependencies
-- [ ] Create components
-- [ ] Test application
-</task_progress>
-</agent_execute_command>
-
-====
-
-EDITING FILES
-
-You have access to two tools for working with files: **agent_write_to_file** and **agent_replace_in_file**. Understanding their roles and selecting the right one for the job will help ensure efficient and accurate modifications.
-
-# agent_write_to_file
-
-## Purpose
-
-- Create a new file, or overwrite the entire contents of an existing file.
-
-## When to Use
-
-- Initial file creation, such as when scaffolding a new project.  
-- Overwriting large boilerplate files where you want to replace the entire content at once.
-- When the complexity or number of changes would make agent_replace_in_file unwieldy or error-prone.
-- When you need to completely restructure a file's content or change its fundamental organization.
-
-## Important Considerations
-
-- Using agent_write_to_file requires providing the file's complete final content.  
-- If you only need to make small changes to an existing file, consider using agent_replace_in_file instead to avoid unnecessarily rewriting the entire file.
-- While agent_write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
-
-# agent_replace_in_file
-
-## Purpose
-
-- Make targeted edits to specific parts of an existing file without overwriting the entire file.
-
-## When to Use
-
-- Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
-- Targeted improvements where only specific portions of the file's content needs to be altered.
-- Especially useful for long files where much of the file will remain unchanged.
-
-## Advantages
-
-- More efficient for minor edits, since you don't need to supply the entire file content.  
-- Reduces the chance of errors that can occur when overwriting large files.
-
-# Choosing the Appropriate Tool
-
-- **Default to agent_replace_in_file** for most changes. It's the safer, more precise option that minimizes potential issues.
-- **Use agent_write_to_file** when:
-  - Creating new files
-  - The changes are so extensive that using agent_replace_in_file would be more complex or risky
-  - You need to completely reorganize or restructure a file
-  - The file is relatively small and the changes affect most of its content
-  - You're generating boilerplate or template files
-
-# Auto-formatting Considerations
-
-- After using either agent_write_to_file or agent_replace_in_file, the user's editor may automatically format the file
-- This auto-formatting may modify the file contents, for example:
-  - Breaking single lines into multiple lines
-  - Adjusting indentation to match project style (e.g. 2 spaces vs 4 spaces vs tabs)
-  - Converting single quotes to double quotes (or vice versa based on project preferences)
-  - Organizing imports (e.g. sorting, grouping by type)
-  - Adding/removing trailing commas in objects and arrays
-  - Enforcing consistent brace style (e.g. same-line vs new-line)
-  - Standardizing semicolon usage (adding or removing based on style)
-- The agent_write_to_file and agent_replace_in_file tool responses will include the final state of the file after any auto-formatting
-- Use this final state as your reference point for any subsequent edits. This is ESPECIALLY important when crafting SEARCH blocks for replace_in_file which require the content to match what's in the file exactly.
-
-# Workflow Tips
-
-1. Before editing, assess the scope of your changes and decide which tool to use.
-2. For targeted edits, apply agent_replace_in_file with carefully crafted SEARCH/REPLACE blocks. If you need multiple changes, you can stack multiple SEARCH/REPLACE blocks within a single agent_replace_in_file call.
-3. IMPORTANT: When you determine that you need to make several changes to the same file, prefer to use a single replace_in_file call with multiple SEARCH/REPLACE blocks. DO NOT prefer to make multiple successive replace_in_file calls for the same file. For example, if you were to add a component to a file, you would use a single replace_in_file call with a SEARCH/REPLACE block to add the import statement and another SEARCH/REPLACE block to add the component usage, rather than making one replace_in_file call for the import statement and then another separate replace_in_file call for the component usage.
-4. For major overhauls or initial file creation, rely on agent_write_to_file.
-5. Once the file has been edited with either agent_write_to_file or agent_replace_in_file, the system will provide you with the final state of the modified file. Use this updated content as the reference point for any subsequent SEARCH/REPLACE operations, since it reflects any auto-formatting or user-applied changes.  
-By thoughtfully selecting between agent_write_to_file and agent_replace_in_file, you can make your file editing process smoother, safer, and more efficient.
-
-====
-`;
-  }
-  getNoUseToolInstructions(context) {
-    return `[ERROR] You did not use a tool in your previous response! Please retry with a tool use.
-
-# Reminder: Instructions for Tool Use
-Tool uses are formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-<tool_name>
-<parameter1_name>value1</parameter1_name>
-<parameter2_name>value2</parameter2_name>
-...
-</tool_name>
-For example:
-<agent_attempt_completion>
-<result>
-I have completed the task...
-</result>
-</agent_attempt_completion>
-Always adhere to this format for all tool uses to ensure proper parsing and execution.
-
-# Next Steps
-
-If you have completed the user's task, use the attempt_completion tool. 
-If you require additional information from the user, use the ask_followup_question tool. 
-Otherwise, if you have not completed the task and do not need additional information, then proceed with the next step of the task. 
-(This is an automated message, so do not respond to it conversationally.)
-${this?.getEnvironmentInfoPrompt?.(context)}`;
-  }
-};
-var NodeApiHandler = class {
-  config;
-  conversationId;
-  constructor(config) {
-    this.config = config;
-  }
-  getModelInfo() {
-    return {
-      providerId: this.config.providerId || "openai-compatible",
-      modelId: this.config.modelId
-    };
-  }
-  async *createMessage(systemPrompt, messages) {
-    let model;
-    if (this.config.providerId === "dify") {
-      const customDify = difyAiProvider.createDifyProvider({
-        baseURL: this.config.baseURL,
-        headers: this.config.headers,
-        fetch: this.config.fetch
-      });
-      model = customDify(this.config.modelId || "", {
-        apiKey: this.config.apiKey,
-        responseMode: "streaming"
-      });
-    } else {
-      const customOpenAI = openai.createOpenAI({
-        baseURL: this.config.baseURL,
-        apiKey: this.config.apiKey,
-        headers: this.config.headers,
-        fetch: this.config.fetch
-      });
-      model = customOpenAI(this.config.modelId || "");
-    }
-    try {
-      const streamOptions = {
-        model,
-        headers: {
-          ...this.config.headers
-        },
-        allowSystemInMessages: true
-      };
-      if (this.config.providerId === "dify" && this.conversationId) {
-        streamOptions.headers["chat-id"] = this.conversationId;
-      }
-      streamOptions.messages = [
-        { role: "system", content: systemPrompt },
-        ...messages.map((m) => ({
-          role: m.role === "system" ? "system" : m.role === "user" ? "user" : "assistant",
-          content: m.content
-        }))
-      ];
-      const { fullStream } = ai.streamText(streamOptions);
-      for await (const part of fullStream) {
-        if (this.config.providerId === "dify" && !this.conversationId && part?.providerMetadata?.difyWorkflowData?.conversationId || part?.providerMetadata?.dify?.conversationId) {
-          this.conversationId = part.providerMetadata?.difyWorkflowData?.conversationId || part.providerMetadata?.dify?.conversationId;
-        }
-        if (part.type === "text-delta") {
-          yield {
-            type: "text",
-            text: part.textDelta || part.text || ""
-          };
-        } else if (part.type === "finish") {
-          yield {
-            type: "usage",
-            usage: {
-              inputTokens: part.usage?.promptTokens || part.totalUsage?.promptTokens || part.totalUsage?.inputTokens || 0,
-              outputTokens: part.usage?.completionTokens || part.totalUsage?.completionTokens || part.totalUsage?.outputTokens || 0
-            }
-          };
-        } else if (part.type === "error") {
-          yield {
-            type: "error",
-            error: part.error
-          };
-        }
-      }
-    } catch (err) {
-      yield {
-        type: "error",
-        error: err
-      };
-    }
-  }
-};
-var WebApiHandler = class {
-  config;
-  conversationId;
-  constructor(config) {
-    this.config = config;
-  }
-  getModelInfo() {
-    return {
-      providerId: this.config.providerId || "openai-compatible",
-      modelId: this.config.modelId
-    };
-  }
-  async *createMessage(systemPrompt, messages) {
-    let model;
-    if (this.config.providerId === "dify") {
-      const customDify = difyAiProvider.createDifyProvider({
-        baseURL: this.config.baseURL,
-        headers: this.config.headers,
-        fetch: this.config.fetch
-      });
-      model = customDify(this.config.modelId || "", {
-        apiKey: this.config.apiKey,
-        responseMode: "streaming"
-      });
-    } else {
-      const customOpenAI = openai.createOpenAI({
-        baseURL: this.config.baseURL,
-        apiKey: this.config.apiKey,
-        headers: this.config.headers,
-        fetch: this.config.fetch
-      });
-      model = customOpenAI(this.config.modelId || "");
-    }
-    try {
-      const streamOptions = {
-        model,
-        headers: {
-          ...this.config.headers
-        },
-        allowSystemInMessages: true
-      };
-      if (this.config.providerId === "dify" && this.conversationId) {
-        streamOptions.headers["chat-id"] = this.conversationId;
-      }
-      streamOptions.messages = [
-        { role: "system", content: systemPrompt },
-        ...messages.map((m) => ({
-          role: m.role === "system" ? "system" : m.role === "user" ? "user" : "assistant",
-          content: m.content
-        }))
-      ];
-      const { fullStream } = ai.streamText(streamOptions);
-      for await (const part of fullStream) {
-        if (this.config.providerId === "dify" && !this.conversationId && part?.providerMetadata?.difyWorkflowData?.conversationId || part?.providerMetadata?.dify?.conversationId) {
-          this.conversationId = part.providerMetadata?.difyWorkflowData?.conversationId || part.providerMetadata?.dify?.conversationId;
-        }
-        if (part.type === "text-delta") {
-          yield {
-            type: "text",
-            text: part.textDelta || part.text || ""
-          };
-        } else if (part.type === "finish") {
-          yield {
-            type: "usage",
-            usage: {
-              inputTokens: part.usage?.promptTokens || part.totalUsage?.promptTokens || part.totalUsage?.inputTokens || 0,
-              outputTokens: part.usage?.completionTokens || part.totalUsage?.completionTokens || part.totalUsage?.outputTokens || 0
-            }
-          };
-        } else if (part.type === "error") {
-          yield {
-            type: "error",
-            error: part.error
-          };
-        }
-      }
-    } catch (err) {
-      yield {
-        type: "error",
-        error: err
-      };
-    }
-  }
-};
 var AgentState = /* @__PURE__ */ ((AgentState2) => {
   AgentState2["IDLE"] = "idle";
   AgentState2["THINKING"] = "thinking";
@@ -1444,10 +688,10 @@ var ClineAgent = class {
             this.setState("finished" /* FINISHED */);
             break;
           } else if (tool.name === "agent_read_file" /* FILE_READ */) {
-            const path4 = tool.params.path;
-            if (path4) {
+            const path = tool.params.path;
+            if (path) {
               try {
-                const content = await this.runtime.fs.readFile(path4);
+                const content = await this.runtime.fs.readFile(path);
                 toolResults.push({ tool, result: content });
               } catch (error) {
                 toolResults.push({ tool, result: `Error: ${error.message}` });
@@ -1463,33 +707,33 @@ var ClineAgent = class {
 STDERR: ${result.stderr}` });
             }
           } else if (tool.name === "agent_write_to_file" /* FILE_NEW */) {
-            const path4 = tool.params.path;
+            const path = tool.params.path;
             const content = tool.params.content;
-            if (path4 && content !== void 0) {
+            if (path && content !== void 0) {
               try {
-                await this.runtime.fs.writeFile(path4, content);
-                toolResults.push({ tool, result: `Successfully wrote to ${path4}` });
+                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 path4 = tool.params.path || this.runtime.env.cwd();
+            const path = tool.params.path || this.runtime.env.cwd();
             try {
-              const files = await this.runtime.fs.readDir(path4);
+              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 path4 = tool.params.path;
+            const path = tool.params.path;
             const diff = tool.params.diff;
-            if (path4 && diff) {
+            if (path && diff) {
               try {
-                const content = await this.runtime.fs.readFile(path4);
+                const content = await this.runtime.fs.readFile(path);
                 const newContent = this.applyDiff(content, diff);
-                await this.runtime.fs.writeFile(path4, newContent);
-                toolResults.push({ tool, result: `Successfully replaced content in ${path4}` });
+                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}` });
               }
@@ -1497,11 +741,11 @@ STDERR: ${result.stderr}` });
               toolResults.push({ tool, result: "Error: Missing path or diff." });
             }
           } else if (tool.name === "agent_delete_file" /* FILE_DELETE */) {
-            const path4 = tool.params.path;
-            if (path4) {
+            const path = tool.params.path;
+            if (path) {
               try {
-                await this.runtime.fs.deleteFile(path4);
-                toolResults.push({ tool, result: `Successfully deleted ${path4}` });
+                await this.runtime.fs.deleteFile(path);
+                toolResults.push({ tool, result: `Successfully deleted ${path}` });
               } catch (e) {
                 toolResults.push({ tool, result: `Error: ${e.message}` });
               }
@@ -1509,11 +753,11 @@ STDERR: ${result.stderr}` });
               toolResults.push({ tool, result: "Error: Missing path." });
             }
           } else if (tool.name === "agent_delete_directory" /* DIR_DELETE */) {
-            const path4 = tool.params.path;
-            if (path4) {
+            const path = tool.params.path;
+            if (path) {
               try {
-                await this.runtime.fs.deleteDirectory(path4);
-                toolResults.push({ tool, result: `Successfully deleted ${path4}` });
+                await this.runtime.fs.deleteDirectory(path);
+                toolResults.push({ tool, result: `Successfully deleted ${path}` });
               } catch (e) {
                 toolResults.push({ tool, result: `Error: ${e.message}` });
               }
@@ -1526,12 +770,12 @@ STDERR: ${result.stderr}` });
             this.setState("waiting_for_user" /* WAITING_FOR_USER */);
             break;
           } else if (tool.name === "agent_search_files" /* SEARCH */) {
-            const path4 = tool.params.path || this.runtime.env.cwd();
+            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(path4, regexStr, filePattern);
+                const result = await this.runtime.fs.searchFiles(path, regexStr, filePattern);
                 toolResults.push({ tool, result: `${result}` });
               } catch (e) {
                 toolResults.push({ tool, result: `Error: ${e.message}` });
@@ -1578,9 +822,9 @@ STDERR: ${result.stderr}` });
             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 path4 = tool.params.path || this.runtime.env.cwd();
+            const path = tool.params.path || this.runtime.env.cwd();
             try {
-              const result = await this.runtime.fs.searchFiles?.(path4, "^(class|function|const|let|var|export|interface|type)\\s+\\w+", "*.ts|*.js");
+              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}` });
@@ -1703,293 +947,6 @@ ${searchBlock.substring(0, 100)}...`);
     return this.memory.getHistory();
   }
 };
-var NodeMemoryManager = class {
-  filePath;
-  maxMessages;
-  /**
-   * @param dbPath 存储历史记录的本地文件路径（例如：'./.cline_memory.json'）
-   * @param maxMessages 保留的最大消息数量，用于简单的历史截断（默认 150）
-   */
-  constructor(dbPath, maxMessages = 150) {
-    this.filePath = path2__namespace.resolve(dbPath);
-    this.maxMessages = maxMessages;
-  }
-  async ensureFile() {
-    try {
-      await fs2__namespace.access(this.filePath);
-    } catch {
-      const dir = path2__namespace.dirname(this.filePath);
-      await fs2__namespace.mkdir(dir, { recursive: true });
-      await fs2__namespace.writeFile(this.filePath, "[]", "utf-8");
-    }
-  }
-  async readMessages() {
-    await this.ensureFile();
-    const data = await fs2__namespace.readFile(this.filePath, "utf-8");
-    try {
-      return JSON.parse(data);
-    } catch {
-      return [];
-    }
-  }
-  async writeMessages(messages) {
-    await this.ensureFile();
-    await fs2__namespace.writeFile(this.filePath, JSON.stringify(messages, null, 2), "utf-8");
-  }
-  async getHistory() {
-    return this.readMessages();
-  }
-  async appendMessage(message) {
-    const messages = await this.readMessages();
-    messages.push(message);
-    await this.writeMessages(messages);
-    await this.condenseHistory();
-  }
-  async condenseHistory() {
-    const messages = await this.readMessages();
-    if (messages.length > this.maxMessages) {
-      const firstMessage = messages[0];
-      const isFirstSystem = firstMessage && firstMessage.role === "system";
-      const sliceCount = messages.length - this.maxMessages;
-      let condensed;
-      if (isFirstSystem) {
-        condensed = [firstMessage, ...messages.slice(sliceCount + 1)];
-      } else {
-        condensed = messages.slice(sliceCount);
-      }
-      await this.writeMessages(condensed);
-    }
-  }
-  async clear() {
-    await this.writeMessages([]);
-  }
-};
-
-// src/memory/WebMemoryManager.ts
-var WebMemoryManager = class {
-  storageKey;
-  maxMessages;
-  inMemoryFallback = [];
-  /**
-   * @param storageKey SessionStorage 中的键名
-   * @param maxMessages 保留的最大消息数量，用于简单的历史截断（默认 150）
-   */
-  constructor(storageKey = "cline_agent_memory", maxMessages = 150) {
-    this.storageKey = storageKey;
-    this.maxMessages = maxMessages;
-  }
-  isStorageAvailable() {
-    try {
-      return typeof window !== "undefined" && typeof window.sessionStorage !== "undefined";
-    } catch {
-      return false;
-    }
-  }
-  readMessages() {
-    if (this.isStorageAvailable()) {
-      const data = window.sessionStorage.getItem(this.storageKey);
-      if (data) {
-        try {
-          return JSON.parse(data);
-        } catch {
-          return [];
-        }
-      }
-      return [];
-    }
-    return this.inMemoryFallback;
-  }
-  writeMessages(messages) {
-    if (this.isStorageAvailable()) {
-      window.sessionStorage.setItem(this.storageKey, JSON.stringify(messages));
-    } else {
-      this.inMemoryFallback = messages;
-    }
-  }
-  async getHistory() {
-    return Promise.resolve(this.readMessages());
-  }
-  async appendMessage(message) {
-    const messages = this.readMessages();
-    messages.push(message);
-    this.writeMessages(messages);
-    await this.condenseHistory();
-  }
-  async condenseHistory() {
-    const messages = this.readMessages();
-    if (messages.length > this.maxMessages) {
-      const firstMessage = messages[0];
-      const isFirstSystem = firstMessage && firstMessage.role === "system";
-      const sliceCount = messages.length - this.maxMessages;
-      let condensed;
-      if (isFirstSystem) {
-        condensed = [firstMessage, ...messages.slice(sliceCount + 1)];
-      } else {
-        condensed = messages.slice(sliceCount);
-      }
-      this.writeMessages(condensed);
-    }
-    return Promise.resolve();
-  }
-  async clear() {
-    this.writeMessages([]);
-    return Promise.resolve();
-  }
-};
-
-// src/runtime/nodeRuntime.ts
-var execAsync = util.promisify(child_process.exec);
-var DefaultNodeRuntime = class {
-  fs = {
-    readFile: async (filepath) => fs2__namespace.readFile(filepath, "utf-8"),
-    writeFile: async (filepath, content) => {
-      await fs2__namespace.mkdir(path2__namespace.dirname(filepath), { recursive: true });
-      await fs2__namespace.writeFile(filepath, content, "utf-8");
-    },
-    deleteFile: (filepath) => fs2__namespace.unlink(filepath),
-    deleteDirectory: (dirpath) => fs2__namespace.rm(dirpath, { recursive: true, force: true }),
-    fileExists: async (filepath) => {
-      try {
-        await fs2__namespace.access(filepath);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    readDir: (dirpath) => fs2__namespace.readdir(dirpath, { withFileTypes: true }),
-    mkdir: async (dirpath) => {
-      await fs2__namespace.mkdir(dirpath, { recursive: true });
-    }
-  };
-  path = {
-    join: (...paths) => path2__namespace.join(...paths)
-  };
-  env = {
-    get: (key) => process.env[key],
-    cwd: () => process.cwd(),
-    osInfo: () => `${os__namespace.type()} ${os__namespace.release()} ${os__namespace.arch()}`,
-    shell: () => process.env.SHELL || process.env.ComSpec || "unknown"
-  };
-  terminal = {
-    execCommand: async (command, options) => {
-      try {
-        const { stdout, stderr } = await execAsync(command, { cwd: options?.cwd || process.cwd() });
-        return { stdout, stderr, exitCode: 0 };
-      } catch (err) {
-        return { stdout: err.stdout || "", stderr: err.stderr || err.message, exitCode: err.code || 1 };
-      }
-    }
-  };
-};
-function createNodeAgent(options) {
-  const runtime = new DefaultNodeRuntime();
-  const api = new NodeApiHandler(options.apiConfig);
-  const memory = options.memory || new NodeMemoryManager(options.dbPath || path2__namespace.join(runtime.env.cwd(), ".cline_memory.json"));
-  const customTools = options.customTools || [];
-  const customToolNames = new Set(customTools.map((t) => t.name));
-  const promptManager = new NodePromptManager();
-  const agent = new ClineAgent({
-    runtime,
-    api,
-    promptManager,
-    memory,
-    customTools,
-    allowDefaultTools: options.allowDefaultTools,
-    maxLoopCount: options.maxLoopCount,
-    customInstructions: options.customInstructions
-  });
-  agent.onToolCall = async (tool) => {
-    if (customToolNames.has(tool.name)) {
-      const customTool = customTools.find((t) => t.name === tool.name);
-      if (customTool.onCall) {
-        return customTool.onCall(tool.params);
-      }
-      return `Error: Custom tool "${tool.name}" does not have an onCall method.`;
-    }
-  };
-  return agent;
-}
-var DefaultWebRuntime = class {
-  vol = new memfs.Volume();
-  memfs = memfs.createFsFromVolume(this.vol).promises;
-  fs = {
-    readFile: async (filepath) => {
-      const content = await this.memfs.readFile(filepath, "utf-8");
-      return content.toString();
-    },
-    writeFile: async (filepath, content) => {
-      const dir = filepath.substring(0, filepath.lastIndexOf("/"));
-      if (dir && dir !== filepath) {
-        await this.memfs.mkdir(dir, { recursive: true });
-      }
-      await this.memfs.writeFile(filepath, content);
-    },
-    deleteFile: (filepath) => this.memfs.unlink(filepath),
-    deleteDirectory: (dirpath) => this.memfs.rm(dirpath, { recursive: true, force: true }),
-    fileExists: async (filepath) => {
-      try {
-        await this.memfs.access(filepath);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    readDir: (dirpath) => {
-      return this.memfs.readdir(dirpath, { withFileTypes: true });
-    },
-    mkdir: async (dirpath) => {
-      await this.memfs.mkdir(dirpath, { recursive: true });
-    }
-  };
-  path = {
-    join: (...paths) => path3__default.default.join(...paths)
-  };
-  env = {
-    get: (key) => void 0,
-    // 浏览器环境中无系统环境变量
-    cwd: () => "/workspace",
-    osInfo: () => typeof navigator !== "undefined" ? navigator.userAgent : "Web Browser",
-    shell: () => ""
-    // 浏览器环境中无真实 shell
-  };
-  terminal = {
-    execCommand: async (command, options) => {
-      return {
-        stdout: `[Mock] Command '${command}' executed in browser sandbox.`,
-        stderr: "",
-        exitCode: 0
-      };
-    }
-  };
-};
-function createWebAgent(options) {
-  const runtime = new DefaultWebRuntime();
-  const api = new WebApiHandler(options.apiConfig);
-  const promptManager = new WebPromptManager();
-  const memory = new WebMemoryManager(options.storageKey || "cline_agent_memory");
-  const customTools = options.customTools || [];
-  const customToolNames = new Set(customTools.map((t) => t.name));
-  const agent = new ClineAgent({
-    runtime,
-    api,
-    promptManager,
-    memory,
-    customTools,
-    allowDefaultTools: options.allowDefaultTools,
-    maxLoopCount: options.maxLoopCount,
-    customInstructions: options.customInstructions
-  });
-  agent.onToolCall = async (tool) => {
-    if (customToolNames.has(tool.name)) {
-      const customTool = customTools.find((t) => t.name === tool.name);
-      if (customTool.onCall) {
-        return customTool.onCall(tool.params);
-      }
-      return `Error: Custom tool "${tool.name}" does not have an onCall method.`;
-    }
-  };
-  return agent;
-}
 
 // src/index.ts
 var VERSION = "0.1.0";
@@ -1998,17 +955,9 @@ globalThis.AI_SDK_LOG_WARNINGS = false;
 exports.AgentDefaultTool = AgentDefaultTool;
 exports.AgentState = AgentState;
 exports.ClineAgent = ClineAgent;
-exports.NodeApiHandler = NodeApiHandler;
-exports.NodeMemoryManager = NodeMemoryManager;
-exports.NodePromptManager = NodePromptManager;
 exports.READ_ONLY_TOOLS = READ_ONLY_TOOLS;
 exports.TOOL_RESULT_BLOCK = TOOL_RESULT_BLOCK;
 exports.VERSION = VERSION;
-exports.WebApiHandler = WebApiHandler;
-exports.WebMemoryManager = WebMemoryManager;
-exports.WebPromptManager = WebPromptManager;
-exports.createNodeAgent = createNodeAgent;
-exports.createWebAgent = createWebAgent;
 exports.defaultTools = defaultTools;
 exports.getToolUseNames = getToolUseNames;
 exports.parseAssistantMessageV2 = parseAssistantMessageV2;