@polka-codes/core 0.5.1 → 0.5.3

package/dist/index.js

@@ -2865,62 +2865,11 @@ Anthropic.Models = Models2;
 Anthropic.ModelInfosPage = ModelInfosPage;
 Anthropic.Beta = Beta;
 
-// src/AiService/UsageMeter.ts
-class UsageMeter {
-  #usage = {
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheWriteTokens: 0,
-    cacheReadTokens: 0,
-    totalCost: 0
-  };
-  #messageCount = 0;
-  maxCost;
-  maxMessageCount;
-  constructor(options = {}) {
-    this.maxCost = options.maxCost || 1000;
-    this.maxMessageCount = options.maxMessageCount || 1000;
-  }
-  addUsage(usage, model) {
-    this.#usage.inputTokens += usage.inputTokens ?? 0;
-    this.#usage.outputTokens += usage.outputTokens ?? 0;
-    this.#usage.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
-    this.#usage.cacheReadTokens += usage.cacheReadTokens ?? 0;
-    if (!usage.totalCost && model) {
-      usage.totalCost = ((model.inputPrice ?? 0) * (usage.inputTokens ?? 0) + (model.outputPrice ?? 0) * (usage.outputTokens ?? 0) + (model.cacheWritesPrice ?? 0) * (usage.cacheWriteTokens ?? 0) + (model.cacheReadsPrice ?? 0) * (usage.cacheReadTokens ?? 0)) / 1e6;
-    }
-    this.#usage.totalCost += usage.totalCost ?? 0;
-  }
-  incrementMessageCount(count = 1) {
-    this.#messageCount += count;
-  }
-  isLimitExceeded() {
-    const messageCount = this.#messageCount >= this.maxMessageCount;
-    const cost = this.#usage.totalCost >= this.maxCost;
-    return {
-      messageCount,
-      cost,
-      result: messageCount || cost
-    };
-  }
-  get usage() {
-    return { ...this.#usage };
-  }
-  printUsage() {
-    console.log("Usages:");
-    console.log(`Input tokens: ${this.#usage.inputTokens}`);
-    console.log(`Output tokens: ${this.#usage.outputTokens}`);
-    console.log(`Cache read tokens: ${this.#usage.cacheReadTokens}`);
-    console.log(`Cache write tokens: ${this.#usage.cacheWriteTokens}`);
-    console.log(`Total cost: ${this.#usage.totalCost}`);
-  }
-}
-
 // src/AiService/AiServiceBase.ts
 class AiServiceBase {
   usageMeter;
   constructor(usageMeter) {
-    this.usageMeter = usageMeter ?? new UsageMeter;
+    this.usageMeter = usageMeter;
   }
   async* send(systemPrompt, messages) {
     this.usageMeter.incrementMessageCount();
@@ -8156,6 +8105,61 @@ class OpenRouterService extends AiServiceBase {
   }
 }
 
+// src/AiService/UsageMeter.ts
+class UsageMeter {
+  #usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheWriteTokens: 0,
+    cacheReadTokens: 0,
+    totalCost: 0
+  };
+  #messageCount = 0;
+  maxCost;
+  maxMessageCount;
+  constructor(options = {}) {
+    this.maxCost = options.maxCost || 1000;
+    this.maxMessageCount = options.maxMessageCount || 1000;
+  }
+  addUsage(usage, model) {
+    this.#usage.inputTokens += usage.inputTokens ?? 0;
+    this.#usage.outputTokens += usage.outputTokens ?? 0;
+    this.#usage.cacheWriteTokens += usage.cacheWriteTokens ?? 0;
+    this.#usage.cacheReadTokens += usage.cacheReadTokens ?? 0;
+    if (!usage.totalCost && model) {
+      usage.totalCost = ((model.inputPrice ?? 0) * (usage.inputTokens ?? 0) + (model.outputPrice ?? 0) * (usage.outputTokens ?? 0) + (model.cacheWritesPrice ?? 0) * (usage.cacheWriteTokens ?? 0) + (model.cacheReadsPrice ?? 0) * (usage.cacheReadTokens ?? 0)) / 1e6;
+    }
+    this.#usage.totalCost += usage.totalCost ?? 0;
+  }
+  incrementMessageCount(count = 1) {
+    this.#messageCount += count;
+  }
+  isLimitExceeded() {
+    const messageCount = this.#messageCount >= this.maxMessageCount;
+    const cost = this.#usage.totalCost >= this.maxCost;
+    return {
+      messageCount,
+      cost,
+      result: messageCount || cost
+    };
+  }
+  get usage() {
+    return { ...this.#usage };
+  }
+  printUsage() {
+    const { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens } = this.#usage;
+    const allTokensZero = inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0;
+    console.log("Usages:");
+    if (!allTokensZero) {
+      console.log(`Input tokens: ${this.#usage.inputTokens}`);
+      console.log(`Output tokens: ${this.#usage.outputTokens}`);
+      console.log(`Cache read tokens: ${this.#usage.cacheReadTokens}`);
+      console.log(`Cache write tokens: ${this.#usage.cacheWriteTokens}`);
+    }
+    console.log(`Total cost: ${this.#usage.totalCost}`);
+  }
+}
+
 // src/AiService/index.ts
 var AiServiceProvider;
 ((AiServiceProvider2) => {
@@ -8182,20 +8186,6 @@ var createService = (provider, options) => {
       return new OpenRouterService(options);
   }
 };
-// src/tool.ts
-var ToolResponseType;
-((ToolResponseType2) => {
-  ToolResponseType2["Reply"] = "Reply";
-  ToolResponseType2["Exit"] = "Exit";
-  ToolResponseType2["Invalid"] = "Invalid";
-  ToolResponseType2["Error"] = "Error";
-  ToolResponseType2["Interrupted"] = "Interrupted";
-  ToolResponseType2["HandOver"] = "HandOver";
-})(ToolResponseType ||= {});
-var getAvailableTools = (provider, allTools) => {
-  return allTools.filter((tool) => tool.isAvailable(provider));
-};
-
 // src/tools/provider.ts
 class MockProvider {
   async readFile(path) {
@@ -8217,7 +8207,7 @@ class MockProvider {
     return ["mock-file.txt"];
   }
   async listCodeDefinitionNames(path) {
-    return ["mockDefinition"];
+    return "mockDefinition";
   }
   async executeCommand(command, needApprove) {
     return { stdout: "mock output", stderr: "", exitCode: 0 };
@@ -8242,6 +8232,7 @@ __export(exports_allTools, {
   listCodeDefinitionNames: () => listCodeDefinitionNames_default,
   handOver: () => handOver_default,
   executeCommand: () => executeCommand_default,
+  delegate: () => delegate_default,
   attemptCompletion: () => attemptCompletion_default,
   askFollowupQuestion: () => askFollowupQuestion_default
 });
@@ -8466,8 +8457,83 @@ var attemptCompletion_default = {
   handler: handler2,
   isAvailable: isAvailable2
 };
-// src/tools/executeCommand.ts
+// src/tools/delegate.ts
 var toolInfo3 = {
+  name: "delegate",
+  description: "Temporarily delegate a task to another agent and receive the result back",
+  parameters: [
+    {
+      name: "agent_name",
+      description: "The name of the agent to delegate the task to",
+      required: true,
+      usageValue: "Name of the target agent"
+    },
+    {
+      name: "task",
+      description: "The task to be completed by the target agent",
+      required: true,
+      usageValue: "Task description"
+    },
+    {
+      name: "context",
+      description: "The context information for the task",
+      required: true,
+      usageValue: "Context information"
+    },
+    {
+      name: "files",
+      description: "The files relevant to the task. Comma separated paths",
+      required: false,
+      usageValue: "Relevant files"
+    }
+  ],
+  examples: [
+    {
+      description: "Delegate a code analysis task to the analyzer agent",
+      parameters: [
+        {
+          name: "agent_name",
+          value: "analyzer"
+        },
+        {
+          name: "task",
+          value: "Analyze the authentication implementation"
+        },
+        {
+          name: "context",
+          value: "Need to understand the security implications of the current auth system"
+        },
+        {
+          name: "files",
+          value: "src/auth/login.ts,src/auth/types.ts"
+        }
+      ]
+    }
+  ]
+};
+var handler3 = async (_provider, args) => {
+  const agentName = getString(args, "agent_name");
+  const task = getString(args, "task");
+  const context = getString(args, "context", undefined);
+  const files = getStringArray(args, "files", []);
+  return {
+    type: "Delegate" /* Delegate */,
+    agentName,
+    task,
+    context,
+    files
+  };
+};
+var isAvailable3 = (_provider) => {
+  return true;
+};
+var delegate_default = {
+  ...toolInfo3,
+  handler: handler3,
+  isAvailable: isAvailable3
+};
+// src/tools/executeCommand.ts
+var toolInfo4 = {
   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 also be executed in the project root directory regardless of executed commands in previous tool uses.`,
   parameters: [
@@ -8500,7 +8566,7 @@ var toolInfo3 = {
     }
   ]
 };
-var handler3 = async (provider, args) => {
+var handler4 = async (provider, args) => {
   if (!provider.executeCommand) {
     return {
       type: "Error" /* Error */,
@@ -8529,16 +8595,16 @@ ${result.stderr}
     message
   };
 };
-var isAvailable3 = (provider) => {
+var isAvailable4 = (provider) => {
   return !!provider.executeCommand;
 };
 var executeCommand_default = {
-  ...toolInfo3,
-  handler: handler3,
-  isAvailable: isAvailable3
+  ...toolInfo4,
+  handler: handler4,
+  isAvailable: isAvailable4
 };
 // src/tools/listCodeDefinitionNames.ts
-var toolInfo4 = {
+var toolInfo5 = {
   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: [
@@ -8550,7 +8616,7 @@ var toolInfo4 = {
     }
   ]
 };
-var handler4 = async (provider, args) => {
+var handler5 = async (provider, args) => {
   if (!provider.listCodeDefinitionNames) {
     return {
       type: "Error" /* Error */,
@@ -8558,26 +8624,25 @@ var handler4 = async (provider, args) => {
     };
   }
   const path = getString(args, "path");
-  const files = await provider.listCodeDefinitionNames(path);
+  const result = 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>`
+<list_code_definition_names_result>
+${result}
+</list_code_definition_names_result>`
   };
 };
-var isAvailable4 = (provider) => {
+var isAvailable5 = (provider) => {
   return !!provider.listCodeDefinitionNames;
 };
 var listCodeDefinitionNames_default = {
-  ...toolInfo4,
-  handler: handler4,
-  isAvailable: isAvailable4
+  ...toolInfo5,
+  handler: handler5,
+  isAvailable: isAvailable5
 };
 // src/tools/listFiles.ts
-var toolInfo5 = {
+var toolInfo6 = {
   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: [
@@ -8616,7 +8681,7 @@ var toolInfo5 = {
     }
   ]
 };
-var handler5 = async (provider, args) => {
+var handler6 = async (provider, args) => {
   if (!provider.listFiles) {
     return {
       type: "Error" /* Error */,
@@ -8637,16 +8702,16 @@ ${files.join(`
 <list_files_truncated>${limitReached}</list_files_truncated>`
   };
 };
-var isAvailable5 = (provider) => {
+var isAvailable6 = (provider) => {
   return !!provider.listFiles;
 };
 var listFiles_default = {
-  ...toolInfo5,
-  handler: handler5,
-  isAvailable: isAvailable5
+  ...toolInfo6,
+  handler: handler6,
+  isAvailable: isAvailable6
 };
 // src/tools/readFile.ts
-var toolInfo6 = {
+var toolInfo7 = {
   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: [
@@ -8678,7 +8743,7 @@ var toolInfo6 = {
     }
   ]
 };
-var handler6 = async (provider, args) => {
+var handler7 = async (provider, args) => {
   if (!provider.readFile) {
     return {
       type: "Error" /* Error */,
@@ -8702,16 +8767,16 @@ var handler6 = async (provider, args) => {
 `)
   };
 };
-var isAvailable6 = (provider) => {
+var isAvailable7 = (provider) => {
   return !!provider.readFile;
 };
 var readFile_default = {
-  ...toolInfo6,
-  handler: handler6,
-  isAvailable: isAvailable6
+  ...toolInfo7,
+  handler: handler7,
+  isAvailable: isAvailable7
 };
 // src/tools/replaceInFile.ts
-var toolInfo7 = {
+var toolInfo8 = {
   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: [
@@ -8795,7 +8860,7 @@ return (
     }
   ]
 };
-var handler7 = async (provider, args) => {
+var handler8 = async (provider, args) => {
   if (!provider.readFile || !provider.writeFile) {
     return {
       type: "Error" /* Error */,
@@ -8812,16 +8877,16 @@ var handler7 = async (provider, args) => {
     message: `<replace_in_file_path>${path}</replace_in_file_path>`
   };
 };
-var isAvailable7 = (provider) => {
+var isAvailable8 = (provider) => {
   return !!provider.readFile && !!provider.writeFile;
 };
 var replaceInFile_default = {
-  ...toolInfo7,
-  handler: handler7,
-  isAvailable: isAvailable7
+  ...toolInfo8,
+  handler: handler8,
+  isAvailable: isAvailable8
 };
 // src/tools/searchFiles.ts
-var toolInfo8 = {
+var toolInfo9 = {
   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: [
@@ -8864,7 +8929,7 @@ var toolInfo8 = {
     }
   ]
 };
-var handler8 = async (provider, args) => {
+var handler9 = async (provider, args) => {
   if (!provider.searchFiles) {
     return {
       type: "Error" /* Error */,
@@ -8887,16 +8952,16 @@ ${files.join(`
 `
   };
 };
-var isAvailable8 = (provider) => {
+var isAvailable9 = (provider) => {
   return !!provider.searchFiles;
 };
 var searchFiles_default = {
-  ...toolInfo8,
-  handler: handler8,
-  isAvailable: isAvailable8
+  ...toolInfo9,
+  handler: handler9,
+  isAvailable: isAvailable9
 };
 // src/tools/writeToFile.ts
-var toolInfo9 = {
+var toolInfo10 = {
   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: [
@@ -8940,7 +9005,7 @@ export default App;
     }
   ]
 };
-var handler9 = async (provider, args) => {
+var handler10 = async (provider, args) => {
   if (!provider.writeFile) {
     return {
       type: "Error" /* Error */,
@@ -8955,16 +9020,16 @@ var handler9 = async (provider, args) => {
     message: `<write_to_file_path>${path}</write_to_file_path><status>Success</status>`
   };
 };
-var isAvailable9 = (provider) => {
+var isAvailable10 = (provider) => {
   return !!provider.writeFile;
 };
 var writeToFile_default = {
-  ...toolInfo9,
-  handler: handler9,
-  isAvailable: isAvailable9
+  ...toolInfo10,
+  handler: handler10,
+  isAvailable: isAvailable10
 };
 // src/tools/handOver.ts
-var toolInfo10 = {
+var toolInfo11 = {
   name: "hand_over",
   description: "Hand over the current task to another agent to complete",
   parameters: [
@@ -8988,7 +9053,7 @@ var toolInfo10 = {
     },
     {
       name: "files",
-      description: "The files relevant to the task",
+      description: "The files relevant to the task. Comma separated paths",
       required: false,
       usageValue: "Relevant files"
     }
@@ -9017,7 +9082,7 @@ var toolInfo10 = {
     }
   ]
 };
-var handler10 = async (_provider, args) => {
+var handler11 = async (_provider, args) => {
   const agentName = getString(args, "agent_name");
   const task = getString(args, "task");
   const context = getString(args, "context", undefined);
@@ -9030,16 +9095,16 @@ var handler10 = async (_provider, args) => {
     files
   };
 };
-var isAvailable10 = (_provider) => {
+var isAvailable11 = (_provider) => {
   return true;
 };
 var handOver_default = {
-  ...toolInfo10,
-  handler: handler10,
-  isAvailable: isAvailable10
+  ...toolInfo11,
+  handler: handler11,
+  isAvailable: isAvailable11
 };
 // src/tools/removeFile.ts
-var toolInfo11 = {
+var toolInfo12 = {
   name: "remove_file",
   description: "Request to remove a file at the specified path.",
   parameters: [
@@ -9062,7 +9127,7 @@ var toolInfo11 = {
     }
   ]
 };
-var handler11 = async (provider, args) => {
+var handler12 = async (provider, args) => {
   if (!provider.removeFile) {
     return {
       type: "Error" /* Error */,
@@ -9076,16 +9141,16 @@ var handler11 = async (provider, args) => {
     message: `<remove_file_path>${path}</remove_file_path><status>Success</status>`
   };
 };
-var isAvailable11 = (provider) => {
+var isAvailable12 = (provider) => {
   return !!provider.removeFile;
 };
 var removeFile_default = {
-  ...toolInfo11,
-  handler: handler11,
-  isAvailable: isAvailable11
+  ...toolInfo12,
+  handler: handler12,
+  isAvailable: isAvailable12
 };
 // src/tools/renameFile.ts
-var toolInfo12 = {
+var toolInfo13 = {
   name: "rename_file",
   description: "Request to rename a file from source path to target path.",
   parameters: [
@@ -9118,7 +9183,7 @@ var toolInfo12 = {
     }
   ]
 };
-var handler12 = async (provider, args) => {
+var handler13 = async (provider, args) => {
   if (!provider.renameFile) {
     return {
       type: "Error" /* Error */,
@@ -9133,14 +9198,42 @@ var handler12 = async (provider, args) => {
     message: `<rename_file_path>${targetPath}</rename_file_path><status>Success</status>`
   };
 };
-var isAvailable12 = (provider) => {
+var isAvailable13 = (provider) => {
   return !!provider.renameFile;
 };
 var renameFile_default = {
-  ...toolInfo12,
-  handler: handler12,
-  isAvailable: isAvailable12
+  ...toolInfo13,
+  handler: handler13,
+  isAvailable: isAvailable13
+};
+// src/tool.ts
+var ToolResponseType;
+((ToolResponseType2) => {
+  ToolResponseType2["Reply"] = "Reply";
+  ToolResponseType2["Exit"] = "Exit";
+  ToolResponseType2["Invalid"] = "Invalid";
+  ToolResponseType2["Error"] = "Error";
+  ToolResponseType2["Interrupted"] = "Interrupted";
+  ToolResponseType2["HandOver"] = "HandOver";
+  ToolResponseType2["Delegate"] = "Delegate";
+})(ToolResponseType ||= {});
+var getAvailableTools = (provider2, allTools2, hasAgent) => {
+  const tools = [];
+  for (const tool of allTools2) {
+    if (!hasAgent) {
+      switch (tool.name) {
+        case handOver_default.name:
+        case delegate_default.name:
+          continue;
+      }
+    }
+    if (tool.isAvailable(provider2)) {
+      tools.push(tool);
+    }
+  }
+  return tools;
 };
+
 // src/Agent/parseAssistantMessage.ts
 function parseAssistantMessage(assistantMessage, tools, toolNamePrefix) {
   const parameterPrefix = `${toolNamePrefix}parameter_`;
@@ -9272,17 +9365,21 @@ ${tools.map((tool) => {
   }).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.
+1. **Thinking Tags**: Use \`<thinking>\` tags to clearly outline your thought process *before* using any tools. This includes:
+  *  Assessing the current situation and available information.
+  *  Defining specific goals and a plan to achieve them.
+  *  Justifying the selection of a particular tool.
+  *  Explaining how you intend to use the tool and what you expect to achieve.
+2. **Tool Selection**: 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. **Formatting**: Formulate tool use only in the specified XML format for each tool.
+4. **User Response**: Wait for the user’s response after each tool use. Do not proceed until you have their confirmation. The user’s response may include:
+  *  Tool success or failure details
+  *  Linter errors
+  *  Terminal output or other relevant feedback
+5. **Conciseness**: Never repeat or quote the entire tool command in your final user-facing message. Summarize outcomes clearly and avoid echoing commands verbatim.
+6. **Brevity**: Respond concisely and move the conversation forward. Do not re-issue the same command or re-trigger tool use without necessity.
+7. **Iteration**: Follow these steps iteratively, confirming success and addressing issues as you go.
+8. **Error Handling**: If a tool returns an error, analyze the error message and adjust your approach accordingly. Consider alternative tools or strategies to achieve the desired outcome.
 
 By adhering to these guidelines:
 - You maintain clarity without accidentally re-invoking tools.
@@ -9408,6 +9505,7 @@ var TaskEventKind;
   TaskEventKind2["ToolError"] = "ToolError";
   TaskEventKind2["ToolInterrupted"] = "ToolInterrupted";
   TaskEventKind2["ToolHandOver"] = "ToolHandOver";
+  TaskEventKind2["ToolDelegate"] = "ToolDelegate";
   TaskEventKind2["UsageExceeded"] = "UsageExceeded";
   TaskEventKind2["EndTask"] = "EndTask";
 })(TaskEventKind ||= {});
@@ -9416,9 +9514,10 @@ class AgentBase {
   ai;
   config;
   handlers;
+  messages = [];
   constructor(name, ai, config) {
     this.ai = ai;
-    if (config.agents && Object.keys(config.agents).length > 0) {
+    if (config.agents && config.agents.length > 0) {
       const agents = agentsPrompt(config.agents, name);
       config.systemPrompt += `
 ${agents}`;
@@ -9430,89 +9529,79 @@ ${agents}`;
     }
     this.handlers = handlers;
   }
-  async startTask({
-    task,
-    context,
-    callback = () => {
-    }
-  }) {
-    const taskInfo = {
-      messages: [],
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheWriteTokens: 0,
-      cacheReadTokens: 0,
-      totalCost: 0
-    };
+  async#callback(event) {
+    await this.config.callback?.(event);
+  }
+  async startTask({ task, context }) {
     let text = `<task>${task}</task>`;
     if (context) {
       text += `
 <context>${context}</context>`;
     }
-    callback({ kind: "StartTask" /* StartTask */, info: taskInfo, systemPrompt: this.config.systemPrompt });
-    return await this.#processLoop(text, taskInfo, callback);
+    this.#callback({ kind: "StartTask" /* StartTask */, agent: this, systemPrompt: this.config.systemPrompt });
+    return await this.#processLoop(text);
   }
-  async#processLoop(userMessage, taskInfo, callback) {
+  async#processLoop(userMessage) {
     let nextRequest = userMessage;
-    while (nextRequest) {
+    while (true) {
       if (this.ai.usageMeter.isLimitExceeded().result) {
-        callback({ kind: "UsageExceeded" /* UsageExceeded */, info: taskInfo });
-        return [{ type: "UsageExceeded" }, taskInfo];
+        this.#callback({ kind: "UsageExceeded" /* UsageExceeded */, agent: this });
+        return { type: "UsageExceeded" };
       }
-      const response = await this.#request(taskInfo, nextRequest, callback);
-      const [newMessage, exitReason] = await this.#handleResponse(taskInfo, response, callback);
-      if (exitReason) {
-        callback({ kind: "EndTask" /* EndTask */, info: taskInfo });
-        return [exitReason, taskInfo];
+      const response = await this.#request(nextRequest);
+      const resp = await this.#handleResponse(response);
+      if ("exit" in resp) {
+        this.#callback({ kind: "EndTask" /* EndTask */, agent: this, exitReason: resp.exit });
+        return resp.exit;
       }
-      nextRequest = newMessage;
+      nextRequest = resp.replay;
     }
-    callback({ kind: "EndTask" /* EndTask */, info: taskInfo });
-    return [{ type: "Exit" /* Exit */, message: "Task completed successfully" }, taskInfo];
   }
-  async continueTask(userMessage, taskInfo, callback = () => {
-  }) {
-    return await this.#processLoop(userMessage, taskInfo, callback);
+  async continueTask(userMessage) {
+    return await this.#processLoop(userMessage);
   }
-  async#request(info, userMessage, callback) {
-    await callback({ kind: "StartRequest" /* StartRequest */, info, userMessage });
-    info.messages.push({
+  async#request(userMessage) {
+    await this.#callback({ kind: "StartRequest" /* StartRequest */, agent: this, userMessage });
+    this.messages.push({
       role: "user",
       content: userMessage
     });
-    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 ?? 0;
-          info.outputTokens = chunk.outputTokens ?? 0;
-          info.cacheWriteTokens = chunk.cacheWriteTokens ?? 0;
-          info.cacheReadTokens = chunk.cacheReadTokens ?? 0;
-          info.totalCost = chunk.totalCost;
-          await callback({ kind: "Usage" /* Usage */, info });
-          break;
-        case "text":
-          currentAssistantMessage += chunk.text;
-          await callback({ kind: "Text" /* Text */, info, newText: chunk.text });
-          break;
-        case "reasoning":
-          await callback({ kind: "Reasoning" /* Reasoning */, info, newText: chunk.text });
-          break;
+    const retryCount = 3;
+    for (let i = 0;i < retryCount; i++) {
+      currentAssistantMessage = "";
+      const stream = this.ai.send(this.config.systemPrompt, this.messages);
+      for await (const chunk of stream) {
+        switch (chunk.type) {
+          case "usage":
+            await this.#callback({ kind: "Usage" /* Usage */, agent: this });
+            break;
+          case "text":
+            currentAssistantMessage += chunk.text;
+            await this.#callback({ kind: "Text" /* Text */, agent: this, newText: chunk.text });
+            break;
+          case "reasoning":
+            await this.#callback({ kind: "Reasoning" /* Reasoning */, agent: this, newText: chunk.text });
+            break;
+        }
+      }
+      if (currentAssistantMessage) {
+        break;
       }
+      console.debug(`Retrying request ${i + 1} of ${retryCount}`);
     }
     if (!currentAssistantMessage) {
       throw new Error("No assistant message received");
     }
-    info.messages.push({
+    this.messages.push({
       role: "assistant",
       content: currentAssistantMessage
     });
     const ret = parseAssistantMessage(currentAssistantMessage, this.config.tools, this.config.toolNamePrefix);
-    await callback({ kind: "EndRequest" /* EndRequest */, info });
+    await this.#callback({ kind: "EndRequest" /* EndRequest */, agent: this });
     return ret;
   }
-  async#handleResponse(info, response, callback) {
+  async#handleResponse(response) {
     const toolReponses = [];
     outer:
       for (const content of response) {
@@ -9520,65 +9609,76 @@ ${agents}`;
           case "text":
             break;
           case "tool_use": {
-            await callback({ kind: "ToolUse" /* ToolUse */, info, tool: content.name });
+            await this.#callback({ kind: "ToolUse" /* ToolUse */, agent: this, tool: content.name });
             const toolResp = await this.#invokeTool(content.name, content.params);
             switch (toolResp.type) {
               case "Reply" /* Reply */:
-                await callback({ kind: "ToolReply" /* ToolReply */, info, tool: content.name });
+                await this.#callback({ kind: "ToolReply" /* ToolReply */, agent: this, tool: content.name });
                 toolReponses.push({ tool: content.name, response: toolResp.message });
                 break;
               case "Exit" /* Exit */:
-                return [undefined, toolResp];
+                return { exit: toolResp };
               case "Invalid" /* Invalid */:
-                await callback({ kind: "ToolInvalid" /* ToolInvalid */, info, tool: content.name });
+                await this.#callback({ kind: "ToolInvalid" /* ToolInvalid */, agent: this, tool: content.name });
                 toolReponses.push({ tool: content.name, response: toolResp.message });
                 break outer;
               case "Error" /* Error */:
-                await callback({ kind: "ToolError" /* ToolError */, info, tool: content.name });
+                await this.#callback({ kind: "ToolError" /* ToolError */, agent: this, tool: content.name });
                 toolReponses.push({ tool: content.name, response: toolResp.message });
                 break outer;
               case "Interrupted" /* Interrupted */:
-                await callback({ kind: "ToolInterrupted" /* ToolInterrupted */, info, tool: content.name });
-                return [undefined, toolResp];
+                await this.#callback({ kind: "ToolInterrupted" /* ToolInterrupted */, agent: this, tool: content.name });
+                return { exit: toolResp };
               case "HandOver" /* HandOver */:
-                await callback({
+                await this.#callback({
                   kind: "ToolHandOver" /* ToolHandOver */,
-                  info,
+                  agent: this,
                   tool: content.name,
                   agentName: toolResp.agentName,
                   task: toolResp.task,
                   context: toolResp.context,
                   files: toolResp.files
                 });
-                return [undefined, toolResp];
+                return { exit: toolResp };
+              case "Delegate" /* Delegate */:
+                await this.#callback({
+                  kind: "ToolDelegate" /* ToolDelegate */,
+                  agent: this,
+                  tool: content.name,
+                  agentName: toolResp.agentName,
+                  task: toolResp.task,
+                  context: toolResp.context,
+                  files: toolResp.files
+                });
+                return { exit: toolResp };
             }
             break;
           }
         }
       }
     if (toolReponses.length === 0 && !this.config.interactive) {
-      return [responsePrompts.requireUseTool, undefined];
+      return { replay: responsePrompts.requireUseTool };
     }
     const finalResp = toolReponses.map(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2)).join(`
 
 `);
-    return [finalResp, undefined];
+    return { replay: finalResp };
   }
   async#invokeTool(name, args) {
     try {
-      const handler13 = this.handlers[name]?.handler;
-      if (!handler13) {
+      const handler14 = this.handlers[name]?.handler;
+      if (!handler14) {
         return {
           type: "Error" /* Error */,
           message: responsePrompts.errorInvokeTool(name, "Tool not found"),
           canRetry: false
         };
       }
-      const resp = await this.onBeforeInvokeTool(name, args);
+      const resp = await this.onBeforeInvokeTool(this.handlers[name].name, args);
       if (resp) {
         return resp;
       }
-      return await handler13(this.config.provider, args);
+      return await handler14(this.config.provider, args);
     } catch (error) {
       return {
         type: "Error" /* Error */,
@@ -9633,12 +9733,13 @@ class AnalyzerAgent extends AgentBase {
       askFollowupQuestion_default,
       attemptCompletion_default,
       handOver_default,
+      delegate_default,
       listCodeDefinitionNames_default,
       listFiles_default,
       readFile_default,
       searchFiles_default
     ];
-    const tools = getAvailableTools(options.provider, agentTools);
+    const tools = getAvailableTools(options.provider, agentTools, (options.agents?.length ?? 0) > 0);
     const toolNamePrefix = "tool_";
     const systemPrompt = fullSystemPrompt({
       os: options.os
@@ -9650,7 +9751,8 @@ class AnalyzerAgent extends AgentBase {
       provider: options.provider,
       interactive: options.interactive,
       agents: options.agents,
-      scripts: options.scripts
+      scripts: options.scripts,
+      callback: options.callback
     });
   }
   onBeforeInvokeTool() {
@@ -9679,7 +9781,7 @@ You are the **Architect** agent, responsible for:
 3. **File Reading** – Use the provided tools to gather information from these files.
 4. **Implementation Plan** – Draft a concise plan detailing steps, resources, and dependencies.
 5. **Review & Improve** – Evaluate and refine the plan.
-6. **Handover** – Provide the final plan, context, and files to the **Coder** agent.
+6. **Handover/Delegate** – Provide the final plan, context, and files to the **Coder** agent.
 
 > **Note**: The **Architect** agent must not make any direct modifications. Your role is limited to creating the implementation plan and handing it over to the **Coder** agent, who will perform any actual changes.
 
@@ -9712,7 +9814,7 @@ You are the **Architect** agent, responsible for:
    - Check the plan for consistency, clarity, and feasibility.
    - Make adjustments or refinements to ensure accuracy and efficiency.
 
-6. **Handover**
+6. **Handover/Delegate**
    - Deliver the final implementation plan, context, and relevant files to the **Coder** agent.
    - Provide any additional instructions or clarifications needed for successful implementation.
 ${toolUsePrompt(tools, toolNamePrefix)}
@@ -9731,12 +9833,13 @@ class ArchitectAgent extends AgentBase {
       askFollowupQuestion_default,
       attemptCompletion_default,
       handOver_default,
+      delegate_default,
       listCodeDefinitionNames_default,
       listFiles_default,
       readFile_default,
       searchFiles_default
     ];
-    const tools = getAvailableTools(options.provider, agentTools);
+    const tools = getAvailableTools(options.provider, agentTools, (options.agents?.length ?? 0) > 0);
     const toolNamePrefix = "tool_";
     const systemPrompt = fullSystemPrompt2({
       os: options.os
@@ -9748,7 +9851,8 @@ class ArchitectAgent extends AgentBase {
       provider: options.provider,
       interactive: options.interactive,
       agents: options.agents,
-      scripts: options.scripts
+      scripts: options.scripts,
+      callback: options.callback
     });
   }
   onBeforeInvokeTool() {
@@ -9765,8 +9869,161 @@ var architectAgentInfo = {
   ]
 };
 
+// src/Agent/CodeFixerAgent/prompts.ts
+var basePrompt = `You are a highly skilled software engineer specializing in debugging and fixing code issues. You have extensive experience with:
+- Type systems and type checking
+- Test frameworks and debugging test failures
+- Code quality tools and best practices
+- Systematic debugging approaches`;
+var codeFixingStrategies = `
+====
+
+CODE FIXING STRATEGIES
+
+1. Type Errors
+   - Analyze type error messages carefully
+   - Check type definitions and imports
+   - Consider type assertions only as a last resort
+   - Verify type compatibility across function boundaries
+   - Look for null/undefined handling issues
+
+2. Test Failures
+   - Examine test output and error messages
+   - Check test setup and fixtures
+   - Verify assertions and expectations
+   - Look for async/timing issues
+   - Consider edge cases and input validation
+
+3. Code Quality Issues
+   - Follow project's coding standards
+   - Address linter warnings systematically
+   - Improve code readability
+   - Fix potential runtime issues
+   - Consider performance implications
+
+4. General Approach
+   - Start with the most critical issues
+   - Make minimal necessary changes
+   - Verify fixes don't introduce new issues
+   - Document complex fixes with comments
+   - Track attempted solutions for each issue`;
+var retryGuidelines = `
+====
+
+RETRY GUIDELINES
+
+1. Before Retrying
+   - Analyze previous attempt's failure
+   - Consider alternative approaches
+   - Check if similar issues were fixed
+   - Verify no new issues were introduced
+
+2. When to Retry
+   - Error message changed but issue persists
+   - New information available about the root cause
+   - Different fixing strategy available
+   - Previous attempt partially successful
+
+3. When to Stop
+   - Maximum retry limit reached
+   - Same error occurs repeatedly
+   - Fix would require major refactoring
+   - Issue requires human intervention
+
+4. After Maximum Retries
+   - Document attempted solutions
+   - Explain why the issue remains
+   - Suggest manual intervention steps
+   - Report any partial improvements`;
+var fullSystemPrompt3 = (info, tools, toolNamePrefix, instructions, scripts, interactive) => `
+${basePrompt}
+${toolUsePrompt(tools, toolNamePrefix)}
+${codeFixingStrategies}
+${retryGuidelines}
+${capabilities(toolNamePrefix)}
+${systemInformation(info)}
+${customInstructions(instructions)}
+${customScripts(scripts)}
+${interactiveMode(interactive)}`;
+
+// src/Agent/CodeFixerAgent/index.ts
+class CodeFixerAgent extends AgentBase {
+  #maxRetries;
+  #retryCount = 0;
+  constructor(options) {
+    const combinedTools = [...options.additionalTools ?? [], ...Object.values(exports_allTools)];
+    const tools = getAvailableTools(options.provider, combinedTools, (options.agents?.length ?? 0) > 0);
+    const toolNamePrefix = "tool_";
+    const systemPrompt = fullSystemPrompt3({
+      os: options.os
+    }, tools, toolNamePrefix, options.customInstructions ?? [], options.scripts ?? {}, options.interactive);
+    super(codeFixerAgentInfo.name, options.ai, {
+      systemPrompt,
+      tools,
+      toolNamePrefix,
+      provider: options.provider,
+      interactive: options.interactive,
+      agents: options.agents,
+      scripts: options.scripts,
+      callback: options.callback
+    });
+    this.#maxRetries = options.maxRetries ?? 5;
+  }
+  async onBeforeInvokeTool(name, args) {
+    if (name === attemptCompletion_default.name) {
+      if (this.#retryCount > this.#maxRetries) {
+        return;
+      }
+      this.#retryCount++;
+      const executeCommand = this.config.provider.executeCommand;
+      if (!executeCommand) {
+        return;
+      }
+      const check = this.config.scripts?.check;
+      const checkCommand = typeof check === "string" ? check : check?.command;
+      if (checkCommand) {
+        try {
+          const { exitCode, stdout, stderr } = await executeCommand(checkCommand, false);
+          if (exitCode !== 0) {
+            return {
+              type: "Reply" /* Reply */,
+              message: responsePrompts.commandResult(checkCommand, exitCode, stdout, stderr)
+            };
+          }
+        } catch (error) {
+          console.warn(`Failed to check code using command: ${checkCommand}`, error);
+        }
+      }
+      const test = this.config.scripts?.test;
+      const testCommand = typeof test === "string" ? test : test?.command;
+      if (testCommand) {
+        try {
+          const { exitCode, stdout, stderr } = await executeCommand(testCommand, false);
+          if (exitCode !== 0) {
+            return {
+              type: "Reply" /* Reply */,
+              message: responsePrompts.commandResult(testCommand, exitCode, stdout, stderr)
+            };
+          }
+        } catch (error) {
+          console.warn(`Failed to test code using command: ${testCommand}`, error);
+        }
+      }
+    }
+  }
+}
+var codeFixerAgentInfo = {
+  name: "codefixer",
+  responsibilities: [
+    "Fixing type errors and type-related issues",
+    "Resolving failing tests",
+    "Addressing code quality issues",
+    "Tracking and reporting unfixed issues"
+  ]
+};
+
 // 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 basePrompt2 = "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.";
 var editingFilesPrompt = (toolNamePrefix) => `
 ====
 
@@ -9866,8 +10123,8 @@ You accomplish a given task iteratively, breaking it down into clear steps and w
 3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use.
 4. Once you've completed the user's task, you must use the ${toolNamePrefix}attempt_completion tool to present the result of the task to the user.
 5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.`;
-var fullSystemPrompt3 = (info, tools, toolNamePrefix, instructions, scripts, interactive) => `
-${basePrompt}
+var fullSystemPrompt4 = (info, tools, toolNamePrefix, instructions, scripts, interactive) => `
+${basePrompt2}
 ${toolUsePrompt(tools, toolNamePrefix)}
 ${editingFilesPrompt(toolNamePrefix)}
 ${capabilities(toolNamePrefix)}
@@ -9883,9 +10140,9 @@ ${interactiveMode(interactive)}
 class CoderAgent extends AgentBase {
   constructor(options) {
     const combinedTools = [...options.additionalTools ?? [], ...Object.values(exports_allTools)];
-    const tools = getAvailableTools(options.provider, combinedTools);
+    const tools = getAvailableTools(options.provider, combinedTools, (options.agents?.length ?? 0) > 0);
     const toolNamePrefix = "tool_";
-    const systemPrompt = fullSystemPrompt3({
+    const systemPrompt = fullSystemPrompt4({
       os: options.os
     }, tools, toolNamePrefix, options.customInstructions ?? [], options.scripts ?? {}, options.interactive);
     super(coderAgentInfo.name, options.ai, {
@@ -9895,10 +10152,14 @@ class CoderAgent extends AgentBase {
       provider: options.provider,
       interactive: options.interactive,
       agents: options.agents,
-      scripts: options.scripts
+      scripts: options.scripts,
+      callback: options.callback
     });
   }
   async onBeforeInvokeTool(name, args) {
+    if (name !== attemptCompletion_default.name) {
+      return;
+    }
     const executeCommand = this.config.provider.executeCommand;
     if (!executeCommand) {
       return;
@@ -9956,46 +10217,66 @@ var coderAgentInfo = {
 // src/Agent/MultiAgent.ts
 class MultiAgent {
   #config;
-  #activeAgent = null;
+  #agents = [];
   constructor(config) {
     this.#config = config;
   }
-  get model() {
-    return this.#activeAgent?.model;
+  async#handleTaskResult(exitReason) {
+    switch (exitReason.type) {
+      case "HandOver" /* HandOver */: {
+        this.#agents.pop();
+        const newContext = await this.#config.getContext?.(exitReason.agentName, exitReason.context, exitReason.files);
+        return await this.#startTask(exitReason.agentName, exitReason.task, newContext);
+      }
+      case "Delegate" /* Delegate */: {
+        const newContext = await this.#config.getContext?.(exitReason.agentName, exitReason.context, exitReason.files);
+        const delegateResult = await this.#startTask(exitReason.agentName, exitReason.task, newContext);
+        switch (delegateResult.type) {
+          case "HandOver" /* HandOver */:
+          case "Delegate" /* Delegate */:
+            console.warn("Unexpected exit reason", delegateResult);
+            break;
+          case "Interrupted" /* Interrupted */:
+            return delegateResult;
+          case "Exit" /* Exit */:
+            return this.continueTask(delegateResult.message);
+        }
+        return delegateResult;
+      }
+      case "Interrupted" /* Interrupted */:
+      case "Exit" /* Exit */:
+        this.#agents.pop();
+        return exitReason;
+      default:
+        return exitReason;
+    }
   }
-  async#startTask(agentName, task, context, callback) {
-    this.#activeAgent = await this.#config.createAgent(agentName);
-    const [exitReason, info] = await this.#activeAgent.startTask({
+  async#startTask(agentName, task, context) {
+    const newAgent = await this.#config.createAgent(agentName);
+    this.#agents.push(newAgent);
+    const exitReason = await newAgent.startTask({
       task,
-      context,
-      callback
+      context
     });
-    if (typeof exitReason === "string") {
-      return [exitReason, info];
-    }
-    if (exitReason.type === "HandOver") {
-      const context2 = await this.#config.getContext?.(agentName, exitReason.context, exitReason.files);
-      return await this.#startTask(exitReason.agentName, exitReason.task, context2, callback);
-    }
-    return [exitReason, info];
+    return await this.#handleTaskResult(exitReason);
   }
   async startTask(options) {
-    if (this.#activeAgent) {
+    if (this.#agents.length > 0) {
       throw new Error("An active agent already exists");
     }
-    return this.#startTask(options.agentName, options.task, options.context, options.callback);
+    return this.#startTask(options.agentName, options.task, options.context);
   }
-  async continueTask(userMessage, taskInfo, callback = () => {
-  }) {
-    if (!this.#activeAgent) {
+  async continueTask(userMessage) {
+    if (!this.#agents.length) {
       throw new Error("No active agent");
     }
-    return this.#activeAgent.continueTask(userMessage, taskInfo, callback);
+    const exitReason = await this.#agents[this.#agents.length - 1].continueTask(userMessage);
+    return await this.#handleTaskResult(exitReason);
   }
 }
 
 // src/Agent/index.ts
-var allAgents = [architectAgentInfo, coderAgentInfo, analyzerAgentInfo];
+var allAgents = [architectAgentInfo, coderAgentInfo, analyzerAgentInfo, codeFixerAgentInfo];
 // src/AiTool/createNewProject.ts
 var prompt = `You are an AiTool designed to assist users in creating new projects. Follow these guidelines:
 
@@ -10314,11 +10595,8 @@ var generateProjectConfig_default = {
   name: "generateProjectConfig",
   description: "Analyzes project files to generate polkacodes config sections",
   prompt: prompt4,
-  formatInput: (params) => {
-    return `<tool_input>
-${params.join(`
-`)}
-</tool_input>`;
+  formatInput: () => {
+    return "";
   },
   parseOutput: (output) => {
     return output.trim();
@@ -10336,15 +10614,14 @@ var executeTool = async (definition, ai, params) => {
     usage
   };
 };
-var executeAgentTool = async (definition, agent, params, callback) => {
+var executeAgentTool = async (definition, agent, params) => {
   if (!definition.agent) {
     throw new Error("Agent not specified");
   }
-  const [exitReason] = await agent.startTask({
+  const exitReason = await agent.startTask({
     agentName: definition.agent,
     task: definition.prompt,
-    context: definition.formatInput(params),
-    callback
+    context: definition.formatInput(params)
   });
   if (exitReason.type === "Exit" /* Exit */) {
     return definition.parseOutput(exitReason.message);
@@ -10357,8 +10634,8 @@ var makeTool = (definition) => {
   };
 };
 var makeAgentTool = (definition) => {
-  return async (agent, params, callback) => {
-    return executeAgentTool(definition, agent, params, callback);
+  return async (agent, params) => {
+    return executeAgentTool(definition, agent, params);
   };
 };
 var generateGitCommitMessage = makeTool(generateGitCommitMessage_default);
@@ -10385,12 +10662,14 @@ export {
   executeTool,
   executeCommand_default as executeCommand,
   executeAgentTool,
+  delegate_default as delegate,
   defaultModels,
   deepSeekModels,
   deepSeekDefaultModelId,
   createService,
   createNewProject,
   coderAgentInfo,
+  codeFixerAgentInfo,
   attemptCompletion_default as attemptCompletion,
   askFollowupQuestion_default as askFollowupQuestion,
   architectAgentInfo,
@@ -10405,6 +10684,7 @@ export {
   MultiAgent,
   MockProvider,
   CoderAgent,
+  CodeFixerAgent,
   ArchitectAgent,
   AnalyzerAgent,
   AiServiceProvider,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/core",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "license": "AGPL-3.0",
   "type": "module",
   "exports": {