@polka-codes/core 0.1.7 → 0.2.0

package/dist/index.js

@@ -7933,7 +7933,7 @@ class OllamaService extends AiServiceBase {
       apiKey: "ollama"
     });
     this.model = {
-      id: options.modelId || "",
+      id: options.modelId || "maryasov/qwen2.5-coder-cline:7b",
       info: openAiModelInfoSaneDefaults
     };
   }
@@ -7970,6 +7970,11 @@ var AiServiceProvider;
   AiServiceProvider2["Ollama"] = "ollama";
   AiServiceProvider2["DeepSeek"] = "deepseek";
 })(AiServiceProvider ||= {});
+var defaultModels = {
+  ["anthropic" /* Anthropic */]: "claude-3-5-sonnet-20241022",
+  ["ollama" /* Ollama */]: "maryasov/qwen2.5-coder-cline:7b",
+  ["deepseek" /* DeepSeek */]: "deepseek-chat"
+};
 var createService = (provider, options) => {
   switch (provider) {
     case "anthropic" /* Anthropic */:
@@ -7980,265 +7985,704 @@ var createService = (provider, options) => {
       return new DeepSeekService(options);
   }
 };
-// src/tools/types.ts
-var ToolResponseType;
-((ToolResponseType2) => {
-  ToolResponseType2["Reply"] = "Reply";
-  ToolResponseType2["Exit"] = "Exit";
-  ToolResponseType2["Invalid"] = "Invalid";
-  ToolResponseType2["Error"] = "Error";
-  ToolResponseType2["Interrupted"] = "Interrupted";
-})(ToolResponseType ||= {});
-// src/tools/tools.ts
-var exports_tools = {};
-__export(exports_tools, {
-  writeToFile: () => writeToFile,
-  searchFiles: () => searchFiles,
-  replaceInFile: () => replaceInFile,
-  readFile: () => readFile,
-  listFiles: () => listFiles,
-  listCodeDefinitionNames: () => listCodeDefinitionNames,
-  executeCommand: () => executeCommand,
-  attemptCompletion: () => attemptCompletion,
-  askFollowupQuestion: () => askFollowupQuestion
-});
-var executeCommand = {
-  name: "execute_command",
-  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. 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.`,
-  parameters: [
-    {
-      name: "command",
-      description: "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.",
-      required: true,
-      usageValue: "Your command here"
-    },
-    {
-      name: "requires_approval",
-      description: `A boolean indicating whether this command requires explicit user approval before execution in case the user has auto-approve mode enabled. Set to 'true' for potentially impactful operations like installing/uninstalling packages, deleting/overwriting files, system configuration changes, network operations, or any commands that could have unintended side effects. Set to 'false' for safe operations like reading files/directories, running development servers, building projects, and other non-destructive operations.`,
-      required: false,
-      usageValue: "true or false"
+// src/tool.ts
+var getAvailableTools = (provider, allTools) => {
+  return allTools.filter((tool) => tool.isAvailable(provider));
+};
+
+// src/Agent/parseAssistantMessage.ts
+function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
+  const parameterPrefix = `${toolNamePrefix}parameter_`;
+  const results = [];
+  const toolTags = tools.map((tool) => `${toolNamePrefix}${tool.name}`);
+  const toolPattern = toolTags.join("|");
+  const tagRegex = new RegExp(`<(${toolPattern})>(.*)<\\/\\1>`, "s");
+  const match = assistantMessage.match(tagRegex);
+  if (match) {
+    const beforeTag = assistantMessage.slice(0, match.index).trim();
+    const fullTagContent = match[0];
+    if (beforeTag) {
+      results.push({
+        type: "text",
+        content: beforeTag
+      });
+    }
+    const tagName = match[1];
+    const toolName = tagName.replace(toolNamePrefix, "");
+    const tool = tools.find((t) => t.name === toolName);
+    if (tool) {
+      const params = {};
+      for (const param of tool.parameters) {
+        const paramName = `${parameterPrefix}${param.name}`;
+        const escapedParamName = paramName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const paramPattern = `<${escapedParamName}>([\\s\\S]*?)<\\/${escapedParamName}>`;
+        const paramMatch = fullTagContent.match(new RegExp(paramPattern, "s"));
+        if (paramMatch) {
+          params[param.name] = paramMatch[1].trim();
+        }
+      }
+      results.push({
+        type: "tool_use",
+        name: toolName,
+        params
+      });
+    } else {
+      results.push({
+        type: "text",
+        content: fullTagContent
+      });
+    }
+    const afterTag = assistantMessage.slice((match.index ?? 0) + fullTagContent.length).trim();
+    if (afterTag) {
+      results.push({
+        type: "text",
+        content: afterTag
+      });
+    }
+  } else {
+    results.push({
+      type: "text",
+      content: assistantMessage
+    });
+  }
+  return results;
+}
+
+// src/Agent/prompts.ts
+var toolInfoPrompt = (tool, toolNamePrefix, parameterPrefix) => `
+## ${toolNamePrefix}${tool.name}
+
+Description: ${tool.description}
+
+Parameters:
+${tool.parameters.map((param) => `- ${parameterPrefix}${param.name}: (${param.required ? "required" : "optional"}) ${param.description}`).join(`
+`)}
+
+Usage:
+<${toolNamePrefix}${tool.name}>
+${tool.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`).join(`
+`)}
+</${toolNamePrefix}${tool.name}>`;
+var toolInfoExamplesPrompt = (idx, tool, example, toolNamePrefix, parameterPrefix) => `
+## Example ${idx + 1}: ${example.description}
+
+<${toolNamePrefix}${tool.name}>
+${example.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.value}</${parameterPrefix}${param.name}>`).join(`
+`)}
+</${toolNamePrefix}${tool.name}>
+`;
+var toolUsePrompt = (tools, toolNamePrefix) => {
+  if (tools.length === 0) {
+    return "";
+  }
+  const parameterPrefix = `${toolNamePrefix}parameter_`;
+  let exampleIndex = 0;
+  return `
+====
+
+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:
+
+<${toolNamePrefix}tool_name>
+<${parameterPrefix}name1>value1</${parameterPrefix}name1>
+<${parameterPrefix}name2>value2</${parameterPrefix}name2>
+...
+</${toolNamePrefix}tool_name>
+
+For example:
+
+<${toolNamePrefix}read_file>
+<${parameterPrefix}path>src/main.js</${parameterPrefix}path>
+</${toolNamePrefix}read_file>
+
+Always adhere to this format for the tool use to ensure proper parsing and execution.
+
+# Tools
+${tools.map((tool) => toolInfoPrompt(tool, toolNamePrefix, parameterPrefix)).join(`
+`)}
+
+# Tool Use Examples
+${tools.map((tool) => {
+    let promp = "";
+    for (const example of tool.examples ?? []) {
+      promp += toolInfoExamplesPrompt(exampleIndex++, tool, example, toolNamePrefix, parameterPrefix);
+    }
+    return promp;
+  }).join("")}
+# Tool Use Guidelines
+
+1. **In \`<thinking>\` tags**, assess what information you have and what you need to proceed.
+2. **Choose one tool at a time per message** based on the task and its description. Do not assume a tool’s outcome without explicit confirmation.
+3. **Formulate tool use only in the specified XML format** for each tool.
+4. **Wait for the user’s response** after each tool use. Do not proceed until you have their confirmation.
+5. The user’s response may include:
+   - Tool success or failure details
+   - Linter errors
+   - Terminal output or other relevant feedback
+6. **Never repeat or quote the entire tool command** in your final user-facing message. Summarize outcomes clearly and avoid echoing commands verbatim.
+7. **Respond concisely** and move the conversation forward. Do not re-issue the same command or re-trigger tool use without necessity.
+8. Follow these steps **iteratively**, confirming success and addressing issues as you go.
+
+By adhering to these guidelines:
+- You maintain clarity without accidentally re-invoking tools.
+- You confirm each step’s results before proceeding.
+- You provide only the necessary information in user-facing replies to prevent re-interpretation as new commands.`;
+};
+var responsePrompts = {
+  errorInvokeTool: (tool, error) => `An error occurred while invoking the tool "${tool}": ${error}`,
+  requireUseTool: "Error: You must use a tool before proceeding",
+  toolResults: (tool, result) => `<tool_response>
+<tool_name>${tool}</tool_name>
+<tool_result>
+${result}
+</tool_result>
+</tool_response>`
+};
+
+// src/Agent/AgentBase.ts
+var ExitReason;
+((ExitReason2) => {
+  ExitReason2["Completed"] = "Completed";
+  ExitReason2["MaxIterations"] = "MaxIterations";
+  ExitReason2["WaitForUserInput"] = "WaitForUserInput";
+  ExitReason2["Interrupted"] = "Interrupted";
+})(ExitReason ||= {});
+
+class AgentBase {
+  ai;
+  config;
+  logger;
+  handlers;
+  constructor(ai, config, logger6) {
+    this.ai = ai;
+    this.config = config;
+    this.logger = logger6;
+    const handlers = {};
+    for (const tool of config.tools) {
+      handlers[tool.name] = tool;
+    }
+    this.handlers = handlers;
+  }
+  async startTask({
+    task,
+    context,
+    maxIterations = 50,
+    callback = () => {
+    }
+  }) {
+    const taskInfo = {
+      options: {
+        maxIterations
+      },
+      messages: [],
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheWriteTokens: 0,
+      cacheReadTokens: 0,
+      totalCost: 0
+    };
+    let text = `<task>${task}</task>`;
+    if (context) {
+      text += `
+<context>${context}</context>`;
+    }
+    return await this.#processLoop(text, taskInfo, callback);
+  }
+  async#processLoop(userMessage, taskInfo, callback) {
+    let nextRequest = userMessage;
+    while (nextRequest) {
+      if (taskInfo.messages.length > taskInfo.options.maxIterations * 2) {
+        callback({ kind: "max_iterations_reached", info: taskInfo });
+        return ["MaxIterations" /* MaxIterations */, taskInfo];
+      }
+      const response = await this.#request(taskInfo, nextRequest, callback);
+      const [newMessage, exitReason] = await this.#handleResponse(taskInfo, response, callback);
+      if (exitReason) {
+        return [exitReason, taskInfo];
+      }
+      nextRequest = newMessage;
+    }
+    callback({ kind: "end_task", info: taskInfo });
+    return ["Completed" /* Completed */, taskInfo];
+  }
+  async continueTask(userMessage, taskInfo, callback) {
+    return await this.#processLoop(userMessage, taskInfo, callback);
+  }
+  async#request(info, userMessage, callback) {
+    await callback({ kind: "start_request", info, userMessage });
+    info.messages.push({
+      role: "user",
+      content: userMessage
+    });
+    this.logger.trace(info.messages, "Sending messages to AI");
+    const stream = this.ai.send(this.config.systemPrompt, info.messages);
+    let currentAssistantMessage = "";
+    for await (const chunk of stream) {
+      switch (chunk.type) {
+        case "usage":
+          info.inputTokens = chunk.inputTokens;
+          info.outputTokens = chunk.outputTokens;
+          info.cacheWriteTokens = chunk.cacheWriteTokens ?? 0;
+          info.cacheReadTokens = chunk.cacheReadTokens ?? 0;
+          info.totalCost = chunk.totalCost;
+          await callback({ kind: "usage", info });
+          break;
+        case "text":
+          currentAssistantMessage += chunk.text;
+          await callback({ kind: "text", info, newText: chunk.text });
+          break;
+      }
+    }
+    if (!currentAssistantMessage) {
+      throw new Error("No assistant message received");
+    }
+    info.messages.push({
+      role: "assistant",
+      content: currentAssistantMessage
+    });
+    const ret = parseAssistantMessage(currentAssistantMessage, this.config.tools, this.config.toolNamePrefix);
+    await callback({ kind: "end_request", info });
+    return ret;
+  }
+  async#handleResponse(info, response, callback) {
+    const toolReponses = [];
+    for (const content of response) {
+      switch (content.type) {
+        case "text":
+          break;
+        case "tool_use": {
+          await callback({ kind: "tool_use", info, tool: content.name });
+          const toolResp = await this.#invokeTool(content.name, content.params);
+          switch (toolResp.type) {
+            case "Reply" /* Reply */:
+              await callback({ kind: "tool_reply", info, tool: content.name });
+              toolReponses.push({ tool: content.name, response: toolResp.message });
+              break;
+            case "Exit" /* Exit */:
+              return [undefined, "Completed" /* Completed */];
+            case "Invalid" /* Invalid */:
+              await callback({ kind: "tool_invalid", info, tool: content.name });
+              toolReponses.push({ tool: content.name, response: toolResp.message });
+              break;
+            case "Error" /* Error */:
+              await callback({ kind: "tool_error", info, tool: content.name });
+              toolReponses.push({ tool: content.name, response: toolResp.message });
+              break;
+            case "Interrupted" /* Interrupted */:
+              await callback({ kind: "tool_interrupted", info, tool: content.name });
+              return [undefined, "Interrupted" /* Interrupted */];
+          }
+          break;
+        }
+      }
+    }
+    if (toolReponses.length === 0 && !this.config.interactive) {
+      return [responsePrompts.requireUseTool, undefined];
+    }
+    const finalResp = toolReponses.map(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2)).join(`
+
+`);
+    return [finalResp, undefined];
+  }
+  async#invokeTool(name, args) {
+    try {
+      const handler = this.handlers[name]?.handler;
+      if (!handler) {
+        return {
+          type: "Error" /* Error */,
+          message: responsePrompts.errorInvokeTool(name, "Tool not found"),
+          canRetry: false
+        };
+      }
+      return await handler(this.config.provider, args);
+    } catch (error) {
+      this.logger.debug(error, "Error invoking tool");
+      return {
+        type: "Error" /* Error */,
+        message: responsePrompts.errorInvokeTool(name, error),
+        canRetry: false
+      };
+    }
+  }
+  get model() {
+    return this.ai.model;
+  }
+}
+// src/tools/provider.ts
+class MockProvider {
+  async readFile(path) {
+    return "mock content";
+  }
+  async writeFile(path, content) {
+    return;
+  }
+  async listFiles(path, recursive, maxCount) {
+    return [["mock-file.txt"], false];
+  }
+  async searchFiles(path, regex, filePattern) {
+    return ["mock-file.txt"];
+  }
+  async listCodeDefinitionNames(path) {
+    return ["mockDefinition"];
+  }
+  async executeCommand(command, needApprove) {
+    return { stdout: "mock output", stderr: "", exitCode: 0 };
+  }
+  async askFollowupQuestion(question, options) {
+    return "mock answer";
+  }
+  async attemptCompletion(result) {
+    return "mock completion";
+  }
+}
+// src/tools/allTools.ts
+var exports_allTools = {};
+__export(exports_allTools, {
+  writeToFile: () => writeToFile_default,
+  searchFiles: () => searchFiles_default,
+  replaceInFile: () => replaceInFile_default,
+  readFile: () => readFile_default,
+  listFiles: () => listFiles_default,
+  listCodeDefinitionNames: () => listCodeDefinitionNames_default,
+  executeCommand: () => executeCommand_default,
+  attemptCompletion: () => attemptCompletion_default,
+  askFollowupQuestion: () => askFollowupQuestion_default
+});
+
+// src/tools/utils/replaceInFile.ts
+var replaceInFile = async (fileContent, diff) => {
+  const blockPattern = /<<<<<+ SEARCH\s*\r?\n([\s\S]*?)\r?\n=======[ \t]*\r?\n([\s\S]*?)\r?\n?>>>>>+ REPLACE/g;
+  const blocks = [];
+  for (let match = blockPattern.exec(diff);match !== null; match = blockPattern.exec(diff)) {
+    blocks.push({ search: match[1], replace: match[2] });
+  }
+  if (blocks.length === 0) {
+    throw new Error("No valid diff blocks found.");
+  }
+  const findAndReplace = (content, search, replace) => {
+    let index = content.indexOf(search);
+    if (index !== -1) {
+      return content.slice(0, index) + replace + content.slice(index + search.length);
+    }
+    const trimmedSearch = search.trim();
+    const trimmedContent = content.trim();
+    const offset = content.indexOf(trimmedContent);
+    index = trimmedContent.indexOf(trimmedSearch);
+    if (index !== -1) {
+      const absoluteIndex = offset + index;
+      return content.slice(0, absoluteIndex) + replace + content.slice(absoluteIndex + trimmedSearch.length);
+    }
+    const normalizedSearch = trimmedSearch.replace(/\s+/g, " ");
+    const normalizedContent = trimmedContent.replace(/\s+/g, " ");
+    index = normalizedContent.indexOf(normalizedSearch);
+    if (index !== -1) {
+      let runningIndex = 0;
+      let actualPos = offset;
+      for (const segment of trimmedSearch.replace(/\s+/g, " ").split(" ")) {
+        const segIndex = content.indexOf(segment, actualPos);
+        if (segIndex === -1) {
+          break;
+        }
+        if (runningIndex === 0) {
+          actualPos = segIndex;
+        } else {
+          actualPos = segIndex + segment.length;
+        }
+        runningIndex++;
+      }
+      const strippedSearch = trimmedSearch.replace(/\s+/g, "");
+      const endPos = actualPos;
+      const startPos = endPos - strippedSearch.length;
+      return content.slice(0, startPos) + replace + content.slice(endPos);
+    }
+    throw new Error(`Could not find the following text in file:
+${search}`);
+  };
+  let updatedFile = fileContent;
+  for (const { search, replace } of blocks) {
+    updatedFile = findAndReplace(updatedFile, search, replace);
+  }
+  return updatedFile;
+};
+// src/tools/utils/getArg.ts
+var getString = (args, name, defaultValue) => {
+  const ret = args[name] ?? defaultValue;
+  if (!ret) {
+    throw new Error(`Missing required argument: ${name}`);
+  }
+  return ret;
+};
+var getStringArray = (args, name, defaultValue) => {
+  const ret = args[name];
+  if (!ret) {
+    if (defaultValue === undefined) {
+      throw new Error(`Missing required argument: ${name}`);
     }
-  ],
-  examples: [
-    {
-      description: "Request to execute a command",
-      parameters: [
-        {
-          name: "command",
-          value: "npm run dev"
-        },
-        {
-          name: "requires_approval",
-          value: "false"
-        }
-      ]
+    return defaultValue;
+  }
+  return ret.split(",");
+};
+var getBoolean = (args, name, defaultValue) => {
+  const ret = args[name];
+  if (!ret) {
+    if (defaultValue === undefined) {
+      throw new Error(`Missing required argument: ${name}`);
     }
-  ]
+    return defaultValue;
+  }
+  switch (ret.toLowerCase()) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    default:
+      throw new Error(`Invalid argument value: ${name}`);
+  }
 };
-var readFile = {
-  name: "read_file",
-  description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string.",
+var getInt = (args, name, defaultValue) => {
+  const ret = args[name];
+  if (!ret) {
+    if (defaultValue === undefined) {
+      throw new Error(`Missing required argument: ${name}`);
+    }
+    return defaultValue;
+  }
+  const parsed = Number.parseInt(ret);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid argument value: ${name}`);
+  }
+  return parsed;
+};
+// src/tools/askFollowupQuestion.ts
+var toolInfo = {
+  name: "ask_followup_question",
+  description: "Whenever you need extra details or clarification to complete the task, pose a direct question to the user. Use this tool sparingly to avoid excessive back-and-forth. If helpful, offer multiple-choice options or examples to guide the user’s response.",
   parameters: [
     {
-      name: "path",
-      description: "The path of the file to read",
+      name: "question",
+      description: "The question to ask the user. This should be a clear, specific question that addresses the information you need.",
       required: true,
-      usageValue: "Comma separated paths here"
+      usageValue: "Your question here"
+    },
+    {
+      name: "options",
+      description: "A comma separated list of possible answers to the question. If not provided, the user will be prompted to provide an answer.",
+      required: false,
+      usageValue: "A comma separated list of possible answers (optional)"
     }
   ],
   examples: [
     {
-      description: "Request to read the contents of a file",
+      description: "Request to ask a question",
       parameters: [
         {
-          name: "path",
-          value: "src/main.js"
+          name: "question",
+          value: "What is the name of the project?"
         }
       ]
     },
     {
-      description: "Request to read multiple files",
+      description: "Request to ask a question with options",
       parameters: [
         {
-          name: "path",
-          value: "src/main.js,src/index.js"
+          name: "question",
+          value: "What framework do you use?"
+        },
+        {
+          name: "options",
+          value: "React,Angular,Vue,Svelte"
         }
       ]
     }
   ]
 };
-var writeToFile = {
-  name: "write_to_file",
-  description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.",
+var handler = async (provider, args) => {
+  if (!provider.askFollowupQuestion) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to ask followup question. Abort."
+    };
+  }
+  const question = getString(args, "question");
+  const options = getStringArray(args, "options", []);
+  const answer = await provider.askFollowupQuestion(question, options);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<ask_followup_question_question>${question}</ask_followup_question_question>
+<ask_followup_question_answer>${answer}</ask_followup_question_answer>`
+  };
+};
+var isAvailable = (provider) => {
+  return !!provider.askFollowupQuestion;
+};
+var askFollowupQuestion_default = {
+  ...toolInfo,
+  handler,
+  isAvailable
+};
+// src/tools/attemptCompletion.ts
+var toolInfo2 = {
+  name: "attempt_completion",
+  description: "Use this tool when you believe the user’s requested task is complete. Indicate that your work is finished, but acknowledge the user may still provide additional instructions or questions if they want to continue.",
   parameters: [
     {
-      name: "path",
-      description: "The path of the file to write to",
-      required: true,
-      usageValue: "File path here"
-    },
-    {
-      name: "content",
-      description: "The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.",
+      name: "result",
+      description: "The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.",
       required: true,
-      usageValue: "Your file content here"
+      usageValue: "Your final result description here"
     }
   ],
   examples: [
     {
-      description: "Request to write content to a file",
+      description: "Request to present the result of the task",
       parameters: [
         {
-          name: "path",
-          value: "src/main.js"
-        },
-        {
-          name: "content",
-          value: `import React from 'react';
-
-function App() {
-  return (
-    <div>
-      <h1>Hello, World!</h1>
-    </div>
-  );
-}
-
-export default App;
-`
+          name: "result",
+          value: "Your final result description here"
         }
       ]
     }
   ]
 };
-var replaceInFile = {
-  name: "replace_in_file",
-  description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
+var handler2 = async (provider, args) => {
+  const result = getString(args, "result");
+  const moreMessage = await provider.attemptCompletion?.(result);
+  if (!moreMessage) {
+    return {
+      type: "Exit" /* Exit */,
+      message: "<completed>true</completed>"
+    };
+  }
+  return {
+    type: "Reply" /* Reply */,
+    message: `<user_message>${moreMessage}</user_message>`
+  };
+};
+var isAvailable2 = (provider) => {
+  return true;
+};
+var attemptCompletion_default = {
+  ...toolInfo2,
+  handler: handler2,
+  isAvailable: isAvailable2
+};
+// src/tools/executeCommand.ts
+var toolInfo3 = {
+  name: "execute_command",
+  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. 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.`,
   parameters: [
     {
-      name: "path",
-      description: "The path of the file to modify",
+      name: "command",
+      description: "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.",
       required: true,
-      usageValue: "File path here"
+      usageValue: "Your command here"
     },
     {
-      name: "diff",
-      description: `One or more SEARCH/REPLACE blocks following this exact format:
-  \`\`\`
-  <<<<<<< SEARCH
-  [exact content to find]
-  =======
-  [new content to replace with]
-  >>>>>>> REPLACE
-  \`\`\`
-  Critical rules:
-  1. SEARCH content must match the associated file section to find EXACTLY:
-     * Match character-for-character including whitespace, indentation, line endings
-     * Include all comments, docstrings, etc.
-  2. SEARCH/REPLACE blocks will ONLY replace the first match occurrence.
-     * Including multiple unique SEARCH/REPLACE blocks if you need to make multiple changes.
-     * Include *just* enough lines in each SEARCH section to uniquely match each set of lines that need to change.
-     * When using multiple SEARCH/REPLACE blocks, list them in the order they appear in the file.
-  3. Keep SEARCH/REPLACE blocks concise:
-     * Break large SEARCH/REPLACE blocks into a series of smaller blocks that each change a small portion of the file.
-     * Include just the changing lines, and a few surrounding lines if needed for uniqueness.
-     * Do not include long runs of unchanging lines in SEARCH/REPLACE blocks.
-     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
-  4. Special operations:
-     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
-     * To delete code: Use empty REPLACE section`,
-      required: true,
-      usageValue: "Search and replace blocks here"
+      name: "requires_approval",
+      description: `A boolean indicating whether this command requires explicit user approval before execution in case the user has auto-approve mode enabled. Set to 'true' for potentially impactful operations like installing/uninstalling packages, deleting/overwriting files, system configuration changes, network operations, or any commands that could have unintended side effects. Set to 'false' for safe operations like reading files/directories, running development servers, building projects, and other non-destructive operations.`,
+      required: false,
+      usageValue: "true or false"
     }
   ],
   examples: [
     {
-      description: "Request to replace sections of content in a file",
+      description: "Request to execute a command",
       parameters: [
         {
-          name: "path",
-          value: "src/main.js"
+          name: "command",
+          value: "npm run dev"
         },
         {
-          name: "diff",
-          value: `
-<<<<<<< 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
-`
+          name: "requires_approval",
+          value: "false"
         }
       ]
     }
   ]
 };
-var searchFiles = {
-  name: "search_files",
-  description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.",
+var handler3 = async (provider, args) => {
+  if (!provider.executeCommand) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to execute command. Abort."
+    };
+  }
+  const command = getString(args, "command");
+  const requiresApproval = getBoolean(args, "requires_approval", false);
+  const result = await provider.executeCommand?.(command, requiresApproval);
+  const message = `<command>${command}</command>
+<command_exit_code>${result.exitCode}</command_exit_code>
+<command_stdout>
+${result.stdout}
+</command_stdout>
+<command_stderr>
+${result.stderr}
+</command_stderr>`;
+  if (result.exitCode === 0) {
+    return {
+      type: "Reply" /* Reply */,
+      message
+    };
+  }
+  return {
+    type: "Error" /* Error */,
+    message
+  };
+};
+var isAvailable3 = (provider) => {
+  return !!provider.executeCommand;
+};
+var executeCommand_default = {
+  ...toolInfo3,
+  handler: handler3,
+  isAvailable: isAvailable3
+};
+// src/tools/listCodeDefinitionNames.ts
+var toolInfo4 = {
+  name: "list_code_definition_names",
+  description: "Request to list definition names (classes, functions, methods, etc.) used in a file. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.",
   parameters: [
     {
       name: "path",
-      description: "The path of the directory to search in (relative to the current working directory). This directory will be recursively searched.",
+      description: "The path of a code file to list top level source code definitions for.",
       required: true,
       usageValue: "Directory path here"
-    },
-    {
-      name: "regex",
-      description: "The regular expression pattern to search for. Uses Rust regex syntax.",
-      required: true,
-      usageValue: "Your regex pattern here"
-    },
-    {
-      name: "file_pattern",
-      description: 'Glob pattern to filter files (e.g., "*.ts" for TypeScript files). If not provided, it will search all files (*).',
-      required: false,
-      usageValue: "file pattern here (optional)"
-    }
-  ],
-  examples: [
-    {
-      description: "Request to perform a regex search across files",
-      parameters: [
-        {
-          name: "path",
-          value: "src"
-        },
-        {
-          name: "regex",
-          value: "^src/components/"
-        },
-        {
-          name: "file_pattern",
-          value: "*.ts"
-        }
-      ]
     }
   ]
 };
-var listFiles = {
+var handler4 = async (provider, args) => {
+  if (!provider.listCodeDefinitionNames) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to list code definition names. Abort."
+    };
+  }
+  const path = getString(args, "path");
+  const files = await provider.listCodeDefinitionNames(path);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<list_code_definition_names_path>${path}</list_code_definition_names_path>
+<list_code_definition_names_files>
+${files.join(`
+`)}
+</list_code_definition_names_files>`
+  };
+};
+var isAvailable4 = (provider) => {
+  return !!provider.listCodeDefinitionNames;
+};
+var listCodeDefinitionNames_default = {
+  ...toolInfo4,
+  handler: handler4,
+  isAvailable: isAvailable4
+};
+// src/tools/listFiles.ts
+var toolInfo5 = {
   name: "list_files",
   description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.",
   parameters: [
@@ -8249,10 +8693,16 @@ var listFiles = {
       usageValue: "Directory path here"
     },
     {
-      name: "depth",
-      description: "The depth of the directory to list contents for. Use 0 for the top-level directory only, 1 for the top-level directory and its children, and so on.",
+      name: "max_count",
+      description: "The maximum number of files to list. Default to 2000",
+      required: false,
+      usageValue: "Maximum number of files to list (optional)"
+    },
+    {
+      name: "recursive",
+      description: "Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.",
       required: false,
-      usageValue: "a number (optional)"
+      usageValue: "true or false (optional)"
     }
   ],
   examples: [
@@ -8264,377 +8714,355 @@ var listFiles = {
           value: "src"
         },
         {
-          name: "recursive",
-          value: "true"
+          name: "max_count",
+          value: "100"
         }
       ]
     }
   ]
 };
-var listCodeDefinitionNames = {
-  name: "list_code_definition_names",
-  description: "Request to list definition names (classes, functions, methods, etc.) used in source code files at the top level of the specified directory. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.",
-  parameters: [
-    {
-      name: "path",
-      description: "The path of the directory (relative to the current working directory ${cwd.toPosix()}) to list top level source code definitions for.",
-      required: true,
-      usageValue: "Directory path here"
-    }
-  ]
+var handler5 = async (provider, args) => {
+  if (!provider.listFiles) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to list files. Abort."
+    };
+  }
+  const path = getString(args, "path");
+  const maxCount = getInt(args, "max_count", 2000);
+  const recursive = getBoolean(args, "recursive", true);
+  const [files, limitReached] = await provider.listFiles(path, recursive, maxCount);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<list_files_path>${path}</list_files_path>
+<list_files_files>
+${files.join(`
+`)}
+</list_files_files>
+<list_files_truncated>${limitReached}</list_files_truncated>`
+  };
 };
-var askFollowupQuestion = {
-  name: "ask_followup_question",
-  description: "Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.",
+var isAvailable5 = (provider) => {
+  return !!provider.listFiles;
+};
+var listFiles_default = {
+  ...toolInfo5,
+  handler: handler5,
+  isAvailable: isAvailable5
+};
+// src/tools/readFile.ts
+var toolInfo6 = {
+  name: "read_file",
+  description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.",
   parameters: [
     {
-      name: "question",
-      description: "The question to ask the user. This should be a clear, specific question that addresses the information you need.",
+      name: "path",
+      description: "The path of the file to read",
       required: true,
-      usageValue: "Your question here"
+      usageValue: "Comma separated paths here"
     }
   ],
   examples: [
     {
-      description: "Request to ask a question",
+      description: "Request to read the contents of a file",
       parameters: [
         {
-          name: "question",
-          value: "What is the name of the project?"
+          name: "path",
+          value: "src/main.js"
+        }
+      ]
+    },
+    {
+      description: "Request to read multiple files",
+      parameters: [
+        {
+          name: "path",
+          value: "src/main.js,src/index.js"
         }
       ]
     }
   ]
 };
-var attemptCompletion = {
-  name: "attempt_completion",
-  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.",
+var handler6 = async (provider, args) => {
+  if (!provider.readFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to read file. Abort."
+    };
+  }
+  const paths = getStringArray(args, "path");
+  const resp = [];
+  for (const path of paths) {
+    const fileContent = await provider.readFile(path);
+    resp.push(`<read_file_file_conten path="${path}">${fileContent}</read_file_file_content>`);
+  }
+  return {
+    type: "Reply" /* Reply */,
+    message: resp.join(`
+`)
+  };
+};
+var isAvailable6 = (provider) => {
+  return !!provider.readFile;
+};
+var readFile_default = {
+  ...toolInfo6,
+  handler: handler6,
+  isAvailable: isAvailable6
+};
+// src/tools/replaceInFile.ts
+var toolInfo7 = {
+  name: "replace_in_file",
+  description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.",
   parameters: [
     {
-      name: "result",
-      description: "The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.",
+      name: "path",
+      description: "The path of the file to modify",
       required: true,
-      usageValue: "Your final result description here"
+      usageValue: "File path here"
+    },
+    {
+      name: "diff",
+      description: `One or more SEARCH/REPLACE blocks following this exact format:
+  \`\`\`
+  <<<<<<< SEARCH
+  [exact content to find]
+  =======
+  [new content to replace with]
+  >>>>>>> REPLACE
+  \`\`\`
+  Critical rules:
+  1. SEARCH content must match the associated file section to find EXACTLY:
+     * Match character-for-character including whitespace, indentation, line endings
+     * Include all comments, docstrings, etc.
+  2. SEARCH/REPLACE blocks will ONLY replace the first match occurrence.
+     * Including multiple unique SEARCH/REPLACE blocks if you need to make multiple changes.
+     * Include *just* enough lines in each SEARCH section to uniquely match each set of lines that need to change.
+     * When using multiple SEARCH/REPLACE blocks, list them in the order they appear in the file.
+  3. Keep SEARCH/REPLACE blocks concise:
+     * Break large SEARCH/REPLACE blocks into a series of smaller blocks that each change a small portion of the file.
+     * Include just the changing lines, and a few surrounding lines if needed for uniqueness.
+     * Do not include long runs of unchanging lines in SEARCH/REPLACE blocks.
+     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
+  4. Special operations:
+     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
+     * To delete code: Use empty REPLACE section`,
+      required: true,
+      usageValue: "Search and replace blocks here"
     }
   ],
   examples: [
     {
-      description: "Request to present the result of the task",
+      description: "Request to replace sections of content in a file",
       parameters: [
         {
-          name: "result",
-          value: "Your final result description here"
-        }
-      ]
-    }
-  ]
-};
-// src/Agent/parseAssistantMessage.ts
-function parseAssistantMessage(assistantMessage, tools2, toolNamePrefix) {
-  const parameterPrefix = `${toolNamePrefix}parameter_`;
-  const results = [];
-  const toolTags = tools2.map((tool) => `${toolNamePrefix}${tool.name}`);
-  const toolPattern = toolTags.join("|");
-  const tagRegex = new RegExp(`<(${toolPattern})>(.*)<\\/\\1>`, "s");
-  const match = assistantMessage.match(tagRegex);
-  if (match) {
-    const beforeTag = assistantMessage.slice(0, match.index).trim();
-    const fullTagContent = match[0];
-    if (beforeTag) {
-      results.push({
-        type: "text",
-        content: beforeTag
-      });
-    }
-    const tagName = match[1];
-    const toolName = tagName.replace(toolNamePrefix, "");
-    const tool = tools2.find((t) => t.name === toolName);
-    if (tool) {
-      const params = {};
-      for (const param of tool.parameters) {
-        const paramName = `${parameterPrefix}${param.name}`;
-        const escapedParamName = paramName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const paramPattern = `<${escapedParamName}>([\\s\\S]*?)<\\/${escapedParamName}>`;
-        const paramMatch = fullTagContent.match(new RegExp(paramPattern, "s"));
-        if (paramMatch) {
-          params[param.name] = paramMatch[1].trim();
-        }
-      }
-      results.push({
-        type: "tool_use",
-        name: toolName,
-        params
-      });
-    } else {
-      results.push({
-        type: "text",
-        content: fullTagContent
-      });
-    }
-    const afterTag = assistantMessage.slice((match.index ?? 0) + fullTagContent.length).trim();
-    if (afterTag) {
-      results.push({
-        type: "text",
-        content: afterTag
-      });
-    }
-  } else {
-    results.push({
-      type: "text",
-      content: assistantMessage
-    });
-  }
-  return results;
-}
-
-// src/Agent/prompts.ts
-var toolInfoPrompt = (tool, toolNamePrefix, parameterPrefix) => `
-## ${toolNamePrefix}${tool.name}
-
-Description: ${tool.description}
-
-Parameters:
-${tool.parameters.map((param) => `- ${parameterPrefix}${param.name}: (${param.required ? "required" : "optional"}) ${param.description}`).join(`
-`)}
-
-Usage:
-<${toolNamePrefix}${tool.name}>
-${tool.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`).join(`
-`)}
-</${toolNamePrefix}${tool.name}>`;
-var toolInfoExamplesPrompt = (idx, tool, example, toolNamePrefix, parameterPrefix) => `
-## Example ${idx + 1}: ${example.description}
-
-<${toolNamePrefix}${tool.name}>
-${example.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.value}</${parameterPrefix}${param.name}>`).join(`
-`)}
-</${toolNamePrefix}${tool.name}>
-`;
-var toolUsePrompt = (tools2, toolNamePrefix) => {
-  if (tools2.length === 0) {
-    return "";
-  }
-  const parameterPrefix = `${toolNamePrefix}parameter_`;
-  let exampleIndex = 0;
-  return `
-====
-
-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:
-
-<${toolNamePrefix}tool_name>
-<${parameterPrefix}name1>value1</${parameterPrefix}name1>
-<${parameterPrefix}name2>value2</${parameterPrefix}name2>
-...
-</${toolNamePrefix}tool_name>
-
-For example:
-
-<${toolNamePrefix}read_file>
-<${parameterPrefix}path>src/main.js</${parameterPrefix}path>
-</${toolNamePrefix}read_file>
-
-Always adhere to this format for the tool use to ensure proper parsing and execution.
-
-# Tools
-${tools2.map((tool) => toolInfoPrompt(tool, toolNamePrefix, parameterPrefix)).join(`
-`)}
-
-# Tool Use Examples
-${tools2.map((tool) => {
-    let promp = "";
-    for (const example of tool.examples ?? []) {
-      promp += toolInfoExamplesPrompt(exampleIndex++, tool, example, toolNamePrefix, parameterPrefix);
-    }
-    return promp;
-  }).join("")}
-# Tool Use Guidelines
+          name: "path",
+          value: "src/main.js"
+        },
+        {
+          name: "diff",
+          value: `
+<<<<<<< SEARCH
+import React from 'react';
+=======
+import React, { useState } from 'react';
+>>>>>>> REPLACE
 
-1. **In \`<thinking>\` tags**, assess what information you have and what you need to proceed.
-2. **Choose one tool at a time per message** based on the task and its description. Do not assume a tool’s outcome without explicit confirmation.
-3. **Formulate tool use only in the specified XML format** for each tool.
-4. **Wait for the user’s response** after each tool use. Do not proceed until you have their confirmation.
-5. The user’s response may include:
-   - Tool success or failure details
-   - Linter errors
-   - Terminal output or other relevant feedback
-6. **Never repeat or quote the entire tool command** in your final user-facing message. Summarize outcomes clearly and avoid echoing commands verbatim.
-7. **Respond concisely** and move the conversation forward. Do not re-issue the same command or re-trigger tool use without necessity.
-8. Follow these steps **iteratively**, confirming success and addressing issues as you go.
+<<<<<<< SEARCH
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
 
-By adhering to these guidelines:
-- You maintain clarity without accidentally re-invoking tools.
-- You confirm each step’s results before proceeding.
-- You provide only the necessary information in user-facing replies to prevent re-interpretation as new commands.`;
-};
-var responsePrompts = {
-  errorInvokeTool: (tool, error) => `An error occurred while invoking the tool "${tool}": ${error}`,
-  requireUseTool: "Error: You must use a tool before proceeding",
-  toolResults: (tool, result) => `<tool_response>
-<tool_name>${tool}</tool_name>
-<tool_result>
-${result}
-</tool_result>
-</tool_response>`
-};
+=======
+>>>>>>> REPLACE
 
-// src/Agent/AgentBase.ts
-class AgentBase {
-  ai;
-  config;
-  logger;
-  constructor(ai, config, logger6) {
-    this.ai = ai;
-    this.config = config;
-    this.logger = logger6;
-  }
-  async startTask({
-    task,
-    context,
-    maxIterations = 50,
-    callback = () => {
+<<<<<<< SEARCH
+return (
+  <div>
+=======
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+return (
+  <div>
+>>>>>>> REPLACE
+`
+        }
+      ]
     }
-  }) {
-    const taskInfo = {
-      options: {
-        maxIterations
-      },
-      messages: [],
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheWriteTokens: 0,
-      cacheReadTokens: 0,
-      totalCost: 0
+  ]
+};
+var handler7 = async (provider, args) => {
+  if (!provider.readFile || !provider.writeFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to replace in file. Abort."
     };
-    let text = `<task>${task}</task>`;
-    if (context) {
-      text += `
-<context>${context}</context>`;
-    }
-    let nextRequest = [
-      {
-        type: "text",
-        text
-      }
-    ];
-    let iterations = 0;
-    while (nextRequest) {
-      if (iterations >= taskInfo.options.maxIterations) {
-        callback({ kind: "max_iterations_reached", info: taskInfo });
-        break;
-      }
-      const response = await this.#request(taskInfo, nextRequest, callback);
-      nextRequest = await this.#handleResponse(taskInfo, response, callback);
-      ++iterations;
-    }
-    callback({ kind: "end_task", info: taskInfo });
-    return taskInfo;
   }
-  async#request(info, userContent, callback) {
-    await callback({ kind: "start_request", info, userContent });
-    info.messages.push({
-      role: "user",
-      content: userContent
-    });
-    this.logger.trace(info.messages, "Sending messages to AI");
-    const stream = this.ai.send(this.config.systemPrompt, info.messages);
-    let currentAssistantMessage = "";
-    for await (const chunk of stream) {
-      switch (chunk.type) {
-        case "usage":
-          info.inputTokens = chunk.inputTokens;
-          info.outputTokens = chunk.outputTokens;
-          info.cacheWriteTokens = chunk.cacheWriteTokens ?? 0;
-          info.cacheReadTokens = chunk.cacheReadTokens ?? 0;
-          info.totalCost = chunk.totalCost;
-          await callback({ kind: "usage", info });
-          break;
-        case "text":
-          currentAssistantMessage += chunk.text;
-          await callback({ kind: "text", info, newText: chunk.text });
-          break;
-      }
+  const path = getString(args, "path");
+  const diff = getString(args, "diff");
+  const fileContent = await provider.readFile(path);
+  const result = await replaceInFile(fileContent, diff);
+  await provider.writeFile(path, result);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<replace_in_file_path>${path}</replace_in_file_path>`
+  };
+};
+var isAvailable7 = (provider) => {
+  return !!provider.readFile && !!provider.writeFile;
+};
+var replaceInFile_default = {
+  ...toolInfo7,
+  handler: handler7,
+  isAvailable: isAvailable7
+};
+// src/tools/searchFiles.ts
+var toolInfo8 = {
+  name: "search_files",
+  description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.",
+  parameters: [
+    {
+      name: "path",
+      description: "The path of the directory to search in (relative to the current working directory). This directory will be recursively searched.",
+      required: true,
+      usageValue: "Directory path here"
+    },
+    {
+      name: "regex",
+      description: "The regular expression pattern to search for. Uses Rust regex syntax.",
+      required: true,
+      usageValue: "Your regex pattern here"
+    },
+    {
+      name: "file_pattern",
+      description: 'Glob pattern to filter files (e.g., "*.ts" for TypeScript files). If not provided, it will search all files (*).',
+      required: false,
+      usageValue: "file pattern here (optional)"
     }
-    if (!currentAssistantMessage) {
-      throw new Error("No assistant message received");
+  ],
+  examples: [
+    {
+      description: "Request to perform a regex search across files",
+      parameters: [
+        {
+          name: "path",
+          value: "src"
+        },
+        {
+          name: "regex",
+          value: "^components/"
+        },
+        {
+          name: "file_pattern",
+          value: "*.ts"
+        }
+      ]
     }
-    info.messages.push({
-      role: "assistant",
-      content: currentAssistantMessage
-    });
-    const ret = parseAssistantMessage(currentAssistantMessage, this.config.tools, this.config.toolNamePrefix);
-    await callback({ kind: "end_request", info });
-    return ret;
+  ]
+};
+var handler8 = async (provider, args) => {
+  if (!provider.searchFiles) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to search files. Abort."
+    };
   }
-  async#handleResponse(info, response, callback) {
-    const toolReponses = [];
-    for (const content of response) {
-      switch (content.type) {
-        case "text":
-          break;
-        case "tool_use": {
-          await callback({ kind: "tool_use", info, tool: content.name });
-          const toolResp = await this.#invokeTool(content.name, content.params);
-          switch (toolResp.type) {
-            case "Reply" /* Reply */:
-              await callback({ kind: "tool_reply", info, tool: content.name });
-              toolReponses.push({ tool: content.name, response: toolResp.message });
-              break;
-            case "Exit" /* Exit */:
-              return;
-            case "Invalid" /* Invalid */:
-              await callback({ kind: "tool_invalid", info, tool: content.name });
-              toolReponses.push({ tool: content.name, response: toolResp.message });
-              break;
-            case "Error" /* Error */:
-              await callback({ kind: "tool_error", info, tool: content.name });
-              toolReponses.push({ tool: content.name, response: toolResp.message });
-              break;
-            case "Interrupted" /* Interrupted */:
-              await callback({ kind: "tool_interrupted", info, tool: content.name });
-              return;
-          }
-          break;
-        }
-      }
+  const path = getString(args, "path");
+  const regex = getString(args, "regex");
+  const filePattern = getString(args, "file_pattern", "*");
+  const files = await provider.searchFiles(path, regex, filePattern);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<search_files_path>${path}</search_files_path>
+<search_files_regex>${regex}</search_files_regex>
+<search_files_file_pattern>${filePattern}</search_files_file_pattern>
+<search_files_files>
+${files.join(`
+`)}
+</search_files_files>
+`
+  };
+};
+var isAvailable8 = (provider) => {
+  return !!provider.searchFiles;
+};
+var searchFiles_default = {
+  ...toolInfo8,
+  handler: handler8,
+  isAvailable: isAvailable8
+};
+// src/tools/writeToFile.ts
+var toolInfo9 = {
+  name: "write_to_file",
+  description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.",
+  parameters: [
+    {
+      name: "path",
+      description: "The path of the file to write to",
+      required: true,
+      usageValue: "File path here"
+    },
+    {
+      name: "content",
+      description: "The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.",
+      required: true,
+      usageValue: "Your file content here"
     }
-    if (toolReponses.length === 0) {
-      return [
+  ],
+  examples: [
+    {
+      description: "Request to write content to a file",
+      parameters: [
         {
-          type: "text",
-          text: responsePrompts.requireUseTool
+          name: "path",
+          value: "src/main.js"
+        },
+        {
+          name: "content",
+          value: `import React from 'react';
+
+function App() {
+  return (
+    <div>
+      <h1>Hello, World!</h1>
+    </div>
+  );
+}
+
+export default App;
+`
         }
-      ];
-    }
-    const finalResp = toolReponses.map(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2)).join(`
-`);
-    return [
-      {
-        type: "text",
-        text: finalResp
-      }
-    ];
-  }
-  async#invokeTool(name, args) {
-    try {
-      return await this.config.toolHandler(name, args);
-    } catch (error) {
-      return {
-        type: "Error" /* Error */,
-        message: responsePrompts.errorInvokeTool(name, error),
-        canRetry: false
-      };
+      ]
     }
+  ]
+};
+var handler9 = async (provider, args) => {
+  if (!provider.writeFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to write file. Abort."
+    };
   }
-  get model() {
-    return this.ai.model;
-  }
-}
+  const path = getString(args, "path");
+  const content = getString(args, "content");
+  await provider.writeFile(path, content);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<write_file_path>${path}</write_file_path><status>Success</status>`
+  };
+};
+var isAvailable9 = (provider) => {
+  return !!provider.writeFile;
+};
+var writeToFile_default = {
+  ...toolInfo9,
+  handler: handler9,
+  isAvailable: isAvailable9
+};
 // src/Agent/CoderAgent/prompts.ts
 var basePrompt = "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.";
 var editingFilesPrompt = (toolNamePrefix) => `
@@ -8716,7 +9144,7 @@ RULES
 
 - You may use \`cd\` to enter any child directory within the current working directory. For example, \`cd myChildDir\`. But you may never move to a parent directory or any directory outside your current path. For example, do not use \`cd ..\`, \`cd /\`, or any absolute path.
 - Always work with relative path names, and never use absolute paths.
-- When generating code file, add a comment on top of the file indicating this file is generated by "polka.codes".
+- When generating code or test or any file that support comments, add a comment on top of the file with a description of the file's purpose and a note that this file is generated by "polka.codes".
 - When generate text file such as README.md, add a footer indicating this file is generated by "polka.codes".
 - Before using the ${toolNamePrefix}execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory, and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command). For example, if you needed to run \`npm install\` in a project that's not in the current working directory, you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`. However, you can only cd into child directory, but never parent directory or root directory or home directory.
 - When using the ${toolNamePrefix}search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the ${toolNamePrefix}search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use ${toolNamePrefix}read_file to examine the full context of interesting matches before using ${toolNamePrefix}replace_in_file to make informed changes.
@@ -8789,9 +9217,27 @@ The following additional commands are provided by the user, and should be follow
 
 ${joined}`;
 };
-var fullSystemPrompt = (info, tools2, toolNamePrefix, instructions, commands) => `
+var interactiveMode = (interactive) => {
+  if (interactive) {
+    return `
+====
+
+INTERACTIVE MODE
+
+You are in interactive mode. This means you may ask user questions to gather additional information to complete the task.
+`;
+  }
+  return `
+====
+
+NON-INTERACTIVE MODE
+
+You are in non-interactive mode. This means you will not be able to ask user questions to gather additional information to complete the task. You should try to use available tools to accomplish the task. If unable to precede further, you may try to end the task and provide a reason.
+`;
+};
+var fullSystemPrompt = (info, tools, toolNamePrefix, instructions, commands, interactive) => `
 ${basePrompt}
-${toolUsePrompt(tools2, toolNamePrefix)}
+${toolUsePrompt(tools, toolNamePrefix)}
 ${editingFilesPrompt(toolNamePrefix)}
 ${capabilities(toolNamePrefix)}
 ${rules(toolNamePrefix)}
@@ -8799,52 +9245,45 @@ ${objectives(toolNamePrefix)}
 ${systemInformation(info)}
 ${customInstructions(instructions)}
 ${customCommands(commands)}
+${interactiveMode(interactive)}
 `;
 
 // src/Agent/CoderAgent/index.ts
-var defaultTools = [
-  exports_tools.executeCommand,
-  exports_tools.readFile,
-  exports_tools.writeToFile,
-  exports_tools.replaceInFile,
-  exports_tools.searchFiles,
-  exports_tools.listFiles,
-  exports_tools.listCodeDefinitionNames,
-  exports_tools.attemptCompletion
-];
-
 class CoderAgent extends AgentBase {
   constructor(options) {
-    const tools2 = options.tools || defaultTools;
+    const combinedTools = [...options.additionalTools ?? [], ...Object.values(exports_allTools)];
+    const tools = getAvailableTools(options.provider, combinedTools);
     const toolNamePrefix = "tool_";
     const systemPrompt = fullSystemPrompt({
       os: options.os
-    }, tools2, toolNamePrefix, options.customInstructions ?? [], options.commands ?? {});
+    }, tools, toolNamePrefix, options.customInstructions ?? [], options.commands ?? {}, options.interactive);
     super(options.ai, {
       systemPrompt,
-      tools: tools2,
+      tools,
       toolNamePrefix,
-      toolHandler: options.toolHandler,
-      customInstructions: options.customInstructions
+      provider: options.provider,
+      interactive: options.interactive
     }, createServiceLogger("CoderAgent"));
   }
 }
 export {
-  writeToFile,
+  writeToFile_default as writeToFile,
   setLogger,
-  searchFiles,
-  replaceInFile,
-  readFile,
-  listFiles,
-  listCodeDefinitionNames,
+  searchFiles_default as searchFiles,
+  replaceInFile_default as replaceInFile,
+  readFile_default as readFile,
+  listFiles_default as listFiles,
+  listCodeDefinitionNames_default as listCodeDefinitionNames,
   getLogger,
-  executeCommand,
+  executeCommand_default as executeCommand,
+  defaultModels,
   createServiceLogger,
   createService,
-  attemptCompletion,
-  askFollowupQuestion,
-  exports_tools as allTools,
-  ToolResponseType,
+  attemptCompletion_default as attemptCompletion,
+  askFollowupQuestion_default as askFollowupQuestion,
+  exports_allTools as allTools,
+  MockProvider,
+  ExitReason,
   CoderAgent,
   AiServiceProvider,
   AgentBase