@polka-codes/core 0.7.2 → 0.7.3

package/dist/index.cjs

@@ -0,0 +1,3457 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentBase: () => AgentBase,
+  AiServiceProvider: () => AiServiceProvider,
+  AnalyzerAgent: () => AnalyzerAgent,
+  ArchitectAgent: () => ArchitectAgent,
+  CodeFixerAgent: () => CodeFixerAgent,
+  CoderAgent: () => CoderAgent,
+  MockProvider: () => MockProvider,
+  MultiAgent: () => MultiAgent,
+  PermissionLevel: () => PermissionLevel,
+  TaskEventKind: () => TaskEventKind,
+  ToolResponseType: () => ToolResponseType,
+  UsageMeter: () => UsageMeter,
+  allAgents: () => allAgents,
+  allTools: () => allTools_exports,
+  analyzerAgentInfo: () => analyzerAgentInfo,
+  anthropicDefaultModelId: () => anthropicDefaultModelId,
+  anthropicModels: () => anthropicModels,
+  architectAgentInfo: () => architectAgentInfo,
+  askFollowupQuestion: () => askFollowupQuestion_default,
+  attemptCompletion: () => attemptCompletion_default,
+  codeFixerAgentInfo: () => codeFixerAgentInfo,
+  coderAgentInfo: () => coderAgentInfo,
+  createNewProject: () => createNewProject,
+  createService: () => createService,
+  deepSeekDefaultModelId: () => deepSeekDefaultModelId,
+  deepSeekModels: () => deepSeekModels,
+  defaultModels: () => defaultModels,
+  delegate: () => delegate_default,
+  executeAgentTool: () => executeAgentTool,
+  executeCommand: () => executeCommand_default,
+  executeTool: () => executeTool,
+  generateGitCommitMessage: () => generateGitCommitMessage,
+  generateGithubPullRequestDetails: () => generateGithubPullRequestDetails,
+  generateProjectConfig: () => generateProjectConfig,
+  getAvailableTools: () => getAvailableTools,
+  handOver: () => handOver_default,
+  listCodeDefinitionNames: () => listCodeDefinitionNames_default,
+  listFiles: () => listFiles_default,
+  makeAgentTool: () => makeAgentTool,
+  makeTool: () => makeTool,
+  modelInfos: () => modelInfos,
+  openAiModelInfoSaneDefaults: () => openAiModelInfoSaneDefaults,
+  readFile: () => readFile_default,
+  removeFile: () => removeFile_default,
+  renameFile: () => renameFile_default,
+  replaceInFile: () => replaceInFile_default,
+  searchFiles: () => searchFiles_default,
+  writeToFile: () => writeToFile_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/AiService/AnthropicService.ts
+var import_sdk = require("@anthropic-ai/sdk");
+
+// src/AiService/AiServiceBase.ts
+var AiServiceBase = class {
+  usageMeter;
+  constructor(usageMeter) {
+    this.usageMeter = usageMeter;
+  }
+  async *send(systemPrompt, messages) {
+    this.usageMeter.incrementMessageCount();
+    const stream = this.sendImpl(systemPrompt, messages);
+    for await (const chunk of stream) {
+      switch (chunk.type) {
+        case "usage":
+          this.usageMeter.addUsage(chunk, this.model);
+          break;
+      }
+      yield chunk;
+    }
+  }
+  async request(systemPrompt, messages) {
+    this.usageMeter.incrementMessageCount();
+    const stream = this.sendImpl(systemPrompt, messages);
+    const usage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheWriteTokens: 0,
+      cacheReadTokens: 0,
+      totalCost: 0
+    };
+    let resp = "";
+    let reasoning = "";
+    for await (const chunk of stream) {
+      switch (chunk.type) {
+        case "usage":
+          usage.inputTokens = chunk.inputTokens ?? 0;
+          usage.outputTokens = chunk.outputTokens ?? 0;
+          usage.cacheWriteTokens = chunk.cacheWriteTokens ?? 0;
+          usage.cacheReadTokens = chunk.cacheReadTokens ?? 0;
+          usage.totalCost = chunk.totalCost;
+          break;
+        case "text":
+          resp += chunk.text;
+          break;
+        case "reasoning":
+          reasoning += chunk.text;
+      }
+    }
+    this.usageMeter.addUsage(usage, this.model);
+    return {
+      response: resp,
+      reasoning,
+      usage
+    };
+  }
+};
+
+// src/AiService/ModelInfo.ts
+var anthropicDefaultModelId = "claude-3-7-sonnet-20250219";
+var anthropicModels = {
+  "claude-3-7-sonnet-20250219": {
+    maxTokens: 8192,
+    contextWindow: 2e5,
+    supportsImages: true,
+    supportsComputerUse: true,
+    supportsPromptCache: true,
+    inputPrice: 3,
+    outputPrice: 15,
+    cacheWritesPrice: 3.75,
+    cacheReadsPrice: 0.3
+  },
+  "claude-3-5-sonnet-20241022": {
+    maxTokens: 8192,
+    contextWindow: 2e5,
+    supportsImages: true,
+    supportsComputerUse: true,
+    supportsPromptCache: true,
+    inputPrice: 3,
+    // $3 per million input tokens
+    outputPrice: 15,
+    // $15 per million output tokens
+    cacheWritesPrice: 3.75,
+    // $3.75 per million tokens
+    cacheReadsPrice: 0.3
+    // $0.30 per million tokens
+  },
+  "claude-3-5-haiku-20241022": {
+    maxTokens: 8192,
+    contextWindow: 2e5,
+    supportsImages: false,
+    supportsPromptCache: true,
+    inputPrice: 0.8,
+    outputPrice: 4,
+    cacheWritesPrice: 1,
+    cacheReadsPrice: 0.08
+  },
+  "claude-3-opus-20240229": {
+    maxTokens: 4096,
+    contextWindow: 2e5,
+    supportsImages: true,
+    supportsPromptCache: true,
+    inputPrice: 15,
+    outputPrice: 75,
+    cacheWritesPrice: 18.75,
+    cacheReadsPrice: 1.5
+  },
+  "claude-3-haiku-20240307": {
+    maxTokens: 4096,
+    contextWindow: 2e5,
+    supportsImages: true,
+    supportsPromptCache: true,
+    inputPrice: 0.25,
+    outputPrice: 1.25,
+    cacheWritesPrice: 0.3,
+    cacheReadsPrice: 0.03
+  }
+};
+var openAiModelInfoSaneDefaults = {
+  maxTokens: -1,
+  contextWindow: 128e3,
+  supportsImages: true,
+  supportsPromptCache: false,
+  inputPrice: 0,
+  outputPrice: 0
+};
+var deepSeekDefaultModelId = "deepseek-chat";
+var deepSeekModels = {
+  "deepseek-chat": {
+    maxTokens: 8e3,
+    contextWindow: 64e3,
+    supportsImages: false,
+    supportsPromptCache: true,
+    // supports context caching, but not in the way anthropic does it (deepseek reports input tokens and reads/writes in the same usage report) FIXME: we need to show users cache stats how deepseek does it
+    inputPrice: 0,
+    // technically there is no input price, it's all either a cache hit or miss (ApiOptions will not show this)
+    outputPrice: 1.1,
+    cacheWritesPrice: 0.27,
+    cacheReadsPrice: 0.07
+  },
+  "deepseek-reasoner": {
+    maxTokens: 8e3,
+    contextWindow: 64e3,
+    supportsImages: false,
+    supportsPromptCache: true,
+    inputPrice: 0,
+    outputPrice: 2.19,
+    cacheWritesPrice: 0.55,
+    cacheReadsPrice: 0.14
+  }
+};
+var modelInfos = {
+  anthropic: anthropicModels,
+  deepseek: deepSeekModels
+};
+
+// src/AiService/AnthropicService.ts
+var AnthropicService = class extends AiServiceBase {
+  #options;
+  #client;
+  model;
+  constructor(options) {
+    super(options.usageMeter);
+    this.#options = options;
+    this.#client = new import_sdk.Anthropic({
+      apiKey: options.apiKey,
+      baseURL: options.baseUrl || void 0
+    });
+    const id = this.#options.model ?? anthropicDefaultModelId;
+    this.model = {
+      provider: "anthropic",
+      id,
+      info: anthropicModels[id] ?? anthropicModels[anthropicDefaultModelId]
+    };
+  }
+  async *sendImpl(systemPrompt, messages) {
+    let stream;
+    const modelId = this.model.id;
+    const cacheControl = this.#options.enableCache ? { type: "ephemeral" } : void 0;
+    switch (modelId) {
+      // 'latest' alias does not support cache_control
+      case "claude-3-7-sonnet-20250219":
+      case "claude-3-5-sonnet-20241022":
+      case "claude-3-5-haiku-20241022":
+      case "claude-3-opus-20240229":
+      case "claude-3-haiku-20240307": {
+        const userMsgIndices = messages.reduce((acc, msg, index) => {
+          if (msg.role === "user") {
+            acc.push(index);
+          }
+          return acc;
+        }, []);
+        const lastUserMsgIndex = userMsgIndices[userMsgIndices.length - 1] ?? -1;
+        const secondLastMsgUserIndex = userMsgIndices[userMsgIndices.length - 2] ?? -1;
+        stream = await this.#client.messages.create({
+          model: modelId,
+          max_tokens: this.model.info.maxTokens || 8192,
+          temperature: 0,
+          system: [
+            {
+              text: systemPrompt,
+              type: "text",
+              cache_control: cacheControl
+            }
+          ],
+          // setting cache breakpoint for system prompt so new tasks can reuse it
+          messages: messages.map((message, index) => {
+            if (index === lastUserMsgIndex || index === secondLastMsgUserIndex) {
+              return {
+                ...message,
+                content: typeof message.content === "string" ? [
+                  {
+                    type: "text",
+                    text: message.content,
+                    cache_control: cacheControl
+                  }
+                ] : message.content.map(
+                  (content, contentIndex) => contentIndex === message.content.length - 1 ? {
+                    ...content,
+                    cache_control: cacheControl
+                  } : content
+                )
+              };
+            }
+            return message;
+          }),
+          stream: true
+        });
+        break;
+      }
+      default: {
+        stream = await this.#client.messages.create({
+          model: modelId,
+          max_tokens: this.model.info.maxTokens || 8192,
+          temperature: 0,
+          system: [{ text: systemPrompt, type: "text" }],
+          messages,
+          // tools,
+          // tool_choice: { type: "auto" },
+          stream: true
+        });
+        break;
+      }
+    }
+    for await (const chunk of stream) {
+      switch (chunk.type) {
+        case "message_start": {
+          const usage = chunk.message.usage;
+          yield {
+            type: "usage",
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens,
+            cacheWriteTokens: usage.cache_creation_input_tokens || 0,
+            cacheReadTokens: usage.cache_read_input_tokens || 0
+          };
+          break;
+        }
+        case "message_delta": {
+          yield {
+            type: "usage",
+            inputTokens: 0,
+            outputTokens: chunk.usage.output_tokens
+          };
+          break;
+        }
+        case "message_stop":
+          break;
+        case "content_block_start":
+          switch (chunk.content_block.type) {
+            case "text":
+              if (chunk.index > 0) {
+                yield {
+                  type: "text",
+                  text: "\n"
+                };
+              }
+              yield {
+                type: "text",
+                text: chunk.content_block.text
+              };
+              break;
+          }
+          break;
+        case "content_block_delta":
+          switch (chunk.delta.type) {
+            case "text_delta":
+              yield {
+                type: "text",
+                text: chunk.delta.text
+              };
+              break;
+          }
+          break;
+        case "content_block_stop":
+          break;
+      }
+    }
+  }
+};
+
+// src/AiService/DeepSeekService.ts
+var import_openai = __toESM(require("openai"), 1);
+
+// src/AiService/utils.ts
+function convertToOpenAiMessages(anthropicMessages) {
+  const openAiMessages = [];
+  for (const anthropicMessage of anthropicMessages) {
+    if (typeof anthropicMessage.content === "string") {
+      openAiMessages.push({
+        role: anthropicMessage.role,
+        content: anthropicMessage.content
+      });
+    } else {
+      if (anthropicMessage.role === "user") {
+        const { nonToolMessages, toolMessages } = anthropicMessage.content.reduce(
+          (acc, part) => {
+            if (part.type === "tool_result") {
+              acc.toolMessages.push(part);
+            } else if (part.type === "text" || part.type === "image") {
+              acc.nonToolMessages.push(part);
+            }
+            return acc;
+          },
+          { nonToolMessages: [], toolMessages: [] }
+        );
+        const toolResultImages = [];
+        for (const toolMessage of toolMessages) {
+          let content;
+          if (typeof toolMessage.content === "string") {
+            content = toolMessage.content;
+          } else {
+            content = toolMessage.content?.map((part) => {
+              if (part.type === "image") {
+                toolResultImages.push(part);
+                return "(see following user message for image)";
+              }
+              return part.text;
+            }).join("\n") ?? "";
+          }
+          openAiMessages.push({
+            role: "tool",
+            tool_call_id: toolMessage.tool_use_id,
+            content
+          });
+        }
+        if (nonToolMessages.length > 0) {
+          openAiMessages.push({
+            role: "user",
+            content: nonToolMessages.map((part) => {
+              if (part.type === "image") {
+                return {
+                  type: "image_url",
+                  image_url: {
+                    url: `data:${part.source.media_type};base64,${part.source.data}`
+                  }
+                };
+              }
+              return { type: "text", text: part.text };
+            })
+          });
+        }
+      } else if (anthropicMessage.role === "assistant") {
+        const { nonToolMessages, toolMessages } = anthropicMessage.content.reduce(
+          (acc, part) => {
+            if (part.type === "tool_use") {
+              acc.toolMessages.push(part);
+            } else if (part.type === "text" || part.type === "image") {
+              acc.nonToolMessages.push(part);
+            }
+            return acc;
+          },
+          { nonToolMessages: [], toolMessages: [] }
+        );
+        let content;
+        if (nonToolMessages.length > 0) {
+          content = nonToolMessages.map((part) => {
+            if (part.type === "image") {
+              return "";
+            }
+            return part.text;
+          }).join("\n");
+        }
+        const tool_calls = toolMessages.map((toolMessage) => ({
+          id: toolMessage.id,
+          type: "function",
+          function: {
+            name: toolMessage.name,
+            // json string
+            arguments: JSON.stringify(toolMessage.input)
+          }
+        }));
+        openAiMessages.push({
+          role: "assistant",
+          content,
+          // Cannot be an empty array. API expects an array with minimum length 1, and will respond with an error if it's empty
+          tool_calls: tool_calls.length > 0 ? tool_calls : void 0
+        });
+      }
+    }
+  }
+  return openAiMessages;
+}
+
+// src/AiService/DeepSeekService.ts
+var DeepSeekService = class extends AiServiceBase {
+  #client;
+  model;
+  constructor(options) {
+    super(options.usageMeter);
+    this.#client = new import_openai.default({
+      baseURL: "https://api.deepseek.com/v1",
+      apiKey: options.apiKey
+    });
+    const id = options.model || deepSeekDefaultModelId;
+    this.model = {
+      provider: "deepseek",
+      id,
+      info: deepSeekModels[id] ?? deepSeekModels[deepSeekDefaultModelId]
+    };
+  }
+  async *sendImpl(systemPrompt, messages) {
+    const openAiMessages = [
+      { role: "system", content: systemPrompt },
+      ...convertToOpenAiMessages(messages)
+    ];
+    const stream = await this.#client.chat.completions.create({
+      model: this.model.id,
+      max_completion_tokens: this.model.info.maxTokens,
+      messages: openAiMessages,
+      temperature: 0,
+      stream: true,
+      stream_options: { include_usage: true }
+    });
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (delta?.reasoning_content) {
+        yield {
+          type: "reasoning",
+          text: delta.reasoning_content
+        };
+      }
+      if (delta?.content) {
+        yield {
+          type: "text",
+          text: delta.content
+        };
+      }
+      if (chunk.usage) {
+        yield {
+          type: "usage",
+          // deepseek reports total input AND cache reads/writes, see context caching: https://api-docs.deepseek.com/guides/kv_cache
+          // where the input tokens is the sum of the cache hits/misses, while anthropic reports them as separate tokens.
+          // This is important to know for
+          // 1) context management truncation algorithm, and
+          // 2) cost calculation (NOTE: we report both input and cache stats but for now set input price to 0 since all the cost calculation will be done using cache hits/misses)
+          inputTokens: chunk.usage.prompt_tokens,
+          outputTokens: chunk.usage.completion_tokens,
+          cacheWriteTokens: chunk.usage.prompt_cache_hit_tokens || 0,
+          cacheReadTokens: chunk.usage.prompt_cache_miss_tokens || 0
+        };
+      }
+    }
+  }
+};
+
+// src/AiService/OllamaService.ts
+var import_openai2 = __toESM(require("openai"), 1);
+var OllamaService = class extends AiServiceBase {
+  #client;
+  model;
+  constructor(options) {
+    super(options.usageMeter);
+    this.#client = new import_openai2.default({
+      baseURL: `${options.baseUrl || "http://localhost:11434"}/v1`,
+      apiKey: "ollama"
+    });
+    this.model = {
+      provider: "ollama",
+      id: options.model || "maryasov/qwen2.5-coder-cline:7b",
+      info: openAiModelInfoSaneDefaults
+    };
+  }
+  async *sendImpl(systemPrompt, messages) {
+    const openAiMessages = [
+      { role: "system", content: systemPrompt },
+      ...convertToOpenAiMessages(messages)
+    ];
+    const stream = await this.#client.chat.completions.create({
+      model: this.model.id,
+      messages: openAiMessages,
+      temperature: 0,
+      stream: true
+    });
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta;
+      if (delta?.content) {
+        yield {
+          type: "text",
+          text: delta.content
+        };
+      }
+    }
+  }
+};
+
+// src/AiService/OpenRouterService.ts
+var import_openai3 = __toESM(require("openai"), 1);
+var OpenRouterService = class extends AiServiceBase {
+  #client;
+  #apiKey;
+  #options;
+  #modelProviderInfo;
+  model;
+  constructor(options) {
+    super(options.usageMeter);
+    if (!options.model) {
+      throw new Error("OpenRouter requires a model");
+    }
+    if (!options.apiKey) {
+      throw new Error("OpenRouter requires an API key");
+    }
+    this.#apiKey = options.apiKey;
+    this.#client = new import_openai3.default({
+      baseURL: "https://openrouter.ai/api/v1",
+      apiKey: options.apiKey,
+      defaultHeaders: {
+        "HTTP-Referer": "https://polka.codes",
+        // Optional, for including your app on openrouter.ai rankings.
+        "X-Title": "Polka Codes"
+        // Optional. Shows in rankings on openrouter.ai.
+      }
+    });
+    this.#options = options;
+    this.model = {
+      provider: "openrouter",
+      id: options.model,
+      info: {}
+    };
+    fetch(`https://openrouter.ai/api/v1/models/${this.model.id}/endpoints`).then((res) => res.json()).then((data) => {
+      this.#modelProviderInfo = data.data;
+    });
+  }
+  async *sendImpl(systemPrompt, messages) {
+    const openAiMessages = [
+      { role: "system", content: systemPrompt },
+      ...convertToOpenAiMessages(messages)
+    ];
+    const cacheControl = this.#options.enableCache ? { type: "ephemeral" } : void 0;
+    switch (this.model.id) {
+      case "anthropic/claude-3.7-sonnet:thinking":
+      case "anthropic/claude-3.7-sonnet":
+      case "anthropic/claude-3.7-sonnet:beta":
+      case "anthropic/claude-3-7-sonnet":
+      case "anthropic/claude-3-7-sonnet:beta":
+      case "anthropic/claude-3.5-sonnet":
+      case "anthropic/claude-3.5-sonnet:beta":
+      case "anthropic/claude-3.5-sonnet-20240620":
+      case "anthropic/claude-3.5-sonnet-20240620:beta":
+      case "anthropic/claude-3-5-haiku":
+      case "anthropic/claude-3-5-haiku:beta":
+      case "anthropic/claude-3-5-haiku-20241022":
+      case "anthropic/claude-3-5-haiku-20241022:beta":
+      case "anthropic/claude-3-haiku":
+      case "anthropic/claude-3-haiku:beta":
+      case "anthropic/claude-3-opus":
+      case "anthropic/claude-3-opus:beta": {
+        openAiMessages[0] = {
+          role: "system",
+          content: [
+            {
+              type: "text",
+              text: systemPrompt,
+              // @ts-ignore-next-line
+              cache_control: cacheControl
+            }
+          ]
+        };
+        const lastTwoUserMessages = openAiMessages.filter((msg) => msg.role === "user").slice(-2);
+        for (const msg of lastTwoUserMessages) {
+          if (typeof msg.content === "string") {
+            msg.content = [{ type: "text", text: msg.content }];
+          }
+          if (Array.isArray(msg.content)) {
+            let lastTextPart = msg.content.filter((part) => part.type === "text").pop();
+            if (!lastTextPart) {
+              lastTextPart = { type: "text", text: "..." };
+              msg.content.push(lastTextPart);
+            }
+            lastTextPart.cache_control = cacheControl;
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    let maxTokens;
+    switch (this.model.id) {
+      case "anthropic/claude-3.7-sonnet:thinking":
+      case "anthropic/claude-3.7-sonnet":
+      case "anthropic/claude-3.7-sonnet:beta":
+      case "anthropic/claude-3-7-sonnet":
+      case "anthropic/claude-3-7-sonnet:beta":
+      case "anthropic/claude-3.5-sonnet":
+      case "anthropic/claude-3.5-sonnet:beta":
+      case "anthropic/claude-3.5-sonnet-20240620":
+      case "anthropic/claude-3.5-sonnet-20240620:beta":
+      case "anthropic/claude-3-5-haiku":
+      case "anthropic/claude-3-5-haiku:beta":
+      case "anthropic/claude-3-5-haiku-20241022":
+      case "anthropic/claude-3-5-haiku-20241022:beta":
+        maxTokens = 8192;
+        break;
+    }
+    let shouldApplyMiddleOutTransform = !this.model.info.supportsPromptCache;
+    if (this.model.id === "deepseek/deepseek-chat") {
+      shouldApplyMiddleOutTransform = true;
+    }
+    const stream = await this.#client.chat.completions.create({
+      model: this.model.id,
+      max_completion_tokens: maxTokens,
+      messages: openAiMessages,
+      temperature: 0,
+      stream: true,
+      transforms: shouldApplyMiddleOutTransform ? ["middle-out"] : void 0,
+      include_reasoning: true
+    });
+    let genId;
+    for await (const chunk of stream) {
+      if ("error" in chunk) {
+        const error = chunk.error;
+        console.error(`OpenRouter API Error: ${error?.code} - ${error?.message}`);
+        throw new Error(`OpenRouter API Error ${error?.code}: ${error?.message}`);
+      }
+      if (!genId && chunk.id) {
+        genId = chunk.id;
+      }
+      const delta = chunk.choices[0]?.delta;
+      if (delta?.reasoning) {
+        yield {
+          type: "reasoning",
+          text: delta.reasoning
+        };
+      }
+      if (delta?.content) {
+        yield {
+          type: "text",
+          text: delta.content
+        };
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    try {
+      const response = await fetch(`https://openrouter.ai/api/v1/generation?id=${genId}`, {
+        headers: {
+          Authorization: `Bearer ${this.#apiKey}`
+        },
+        signal: controller.signal
+        // this request hangs sometimes
+      });
+      const responseBody = await response.json();
+      const generation = responseBody.data ?? {};
+      let totalCost = generation.total_cost || 0;
+      if (generation.is_byok && this.#modelProviderInfo) {
+        const price = this.#modelProviderInfo.endpoints.find((e) => e.provider_name === generation.provider_name)?.pricing;
+        if (price) {
+          totalCost += (generation.native_tokens_prompt || 0) * price.request;
+          totalCost += (generation.native_tokens_completion || 0) * price.completion;
+        }
+      }
+      yield {
+        type: "usage",
+        // cacheWriteTokens: 0,
+        // cacheReadTokens: 0,
+        // openrouter generation endpoint fails often
+        inputTokens: generation.native_tokens_prompt || 0,
+        outputTokens: generation.native_tokens_completion || 0,
+        totalCost
+      };
+    } catch (error) {
+      console.error("Error fetching OpenRouter generation details:", error);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/AiService/UsageMeter.ts
+var import_lodash = require("lodash");
+var UsageMeter = class {
+  #usage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheWriteTokens: 0,
+    cacheReadTokens: 0,
+    totalCost: 0
+  };
+  #messageCount = 0;
+  #prices = {};
+  maxCost;
+  maxMessageCount;
+  constructor(options = {}) {
+    this.maxCost = options.maxCost || 1e3;
+    this.maxMessageCount = options.maxMessageCount || 1e3;
+    this.#prices = (0, import_lodash.merge)({}, modelInfos, options.prices ?? {});
+  }
+  /**
+   * Add usage metrics to the current totals
+   */
+  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) {
+      const modelInfo = this.#prices[model.provider]?.[model.id] ?? {};
+      usage.totalCost = ((modelInfo.inputPrice ?? 0) * (usage.inputTokens ?? 0) + (modelInfo.outputPrice ?? 0) * (usage.outputTokens ?? 0) + (modelInfo.cacheWritesPrice ?? 0) * (usage.cacheWriteTokens ?? 0) + (modelInfo.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 current usage totals
+   */
+  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 = /* @__PURE__ */ ((AiServiceProvider2) => {
+  AiServiceProvider2["Anthropic"] = "anthropic";
+  AiServiceProvider2["Ollama"] = "ollama";
+  AiServiceProvider2["DeepSeek"] = "deepseek";
+  AiServiceProvider2["OpenRouter"] = "openrouter";
+  return AiServiceProvider2;
+})(AiServiceProvider || {});
+var defaultModels = {
+  ["anthropic" /* Anthropic */]: "claude-3-7-sonnet-20250219",
+  ["ollama" /* Ollama */]: "maryasov/qwen2.5-coder-cline:7b",
+  ["deepseek" /* DeepSeek */]: "deepseek-chat",
+  ["openrouter" /* OpenRouter */]: "anthropic/claude-3.7-sonnet"
+};
+var createService = (provider, options) => {
+  switch (provider) {
+    case "anthropic" /* Anthropic */:
+      return new AnthropicService(options);
+    case "ollama" /* Ollama */:
+      return new OllamaService(options);
+    case "deepseek" /* DeepSeek */:
+      return new DeepSeekService(options);
+    case "openrouter" /* OpenRouter */:
+      return new OpenRouterService(options);
+  }
+};
+
+// src/tools/provider.ts
+var MockProvider = class {
+  async readFile(path) {
+    return "mock content";
+  }
+  async writeFile(path, content) {
+    return;
+  }
+  async removeFile(path) {
+    return;
+  }
+  async renameFile(sourcePath, targetPath) {
+    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 allTools_exports = {};
+__export(allTools_exports, {
+  askFollowupQuestion: () => askFollowupQuestion_default,
+  attemptCompletion: () => attemptCompletion_default,
+  delegate: () => delegate_default,
+  executeCommand: () => executeCommand_default,
+  handOver: () => handOver_default,
+  listCodeDefinitionNames: () => listCodeDefinitionNames_default,
+  listFiles: () => listFiles_default,
+  readFile: () => readFile_default,
+  removeFile: () => removeFile_default,
+  renameFile: () => renameFile_default,
+  replaceInFile: () => replaceInFile_default,
+  searchFiles: () => searchFiles_default,
+  writeToFile: () => writeToFile_default
+});
+
+// src/tool.ts
+var PermissionLevel = /* @__PURE__ */ ((PermissionLevel2) => {
+  PermissionLevel2[PermissionLevel2["None"] = 0] = "None";
+  PermissionLevel2[PermissionLevel2["Read"] = 1] = "Read";
+  PermissionLevel2[PermissionLevel2["Write"] = 2] = "Write";
+  PermissionLevel2[PermissionLevel2["Arbitrary"] = 3] = "Arbitrary";
+  return PermissionLevel2;
+})(PermissionLevel || {});
+var ToolResponseType = /* @__PURE__ */ ((ToolResponseType2) => {
+  ToolResponseType2["Reply"] = "Reply";
+  ToolResponseType2["Exit"] = "Exit";
+  ToolResponseType2["Invalid"] = "Invalid";
+  ToolResponseType2["Error"] = "Error";
+  ToolResponseType2["Interrupted"] = "Interrupted";
+  ToolResponseType2["HandOver"] = "HandOver";
+  ToolResponseType2["Delegate"] = "Delegate";
+  return ToolResponseType2;
+})(ToolResponseType || {});
+
+// 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 === void 0) {
+    throw new Error(`Missing required argument: ${name}`);
+  }
+  return ret;
+};
+var getStringArray = (args, name, defaultValue) => {
+  const ret = args[name];
+  if (ret === void 0) {
+    if (defaultValue === void 0) {
+      throw new Error(`Missing required argument: ${name}`);
+    }
+    return defaultValue;
+  }
+  if (ret === "") {
+    return [];
+  }
+  return ret.split(",").map((s) => s.trim());
+};
+var getBoolean = (args, name, defaultValue) => {
+  const ret = args[name];
+  if (ret === void 0) {
+    if (defaultValue === void 0) {
+      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 getInt = (args, name, defaultValue) => {
+  const ret = args[name];
+  if (ret === void 0) {
+    if (defaultValue === void 0) {
+      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\u2019s response.",
+  parameters: [
+    {
+      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: "Your question here"
+    },
+    {
+      name: "options",
+      description: "A comma separated list of possible answers to the question. Ordered by preference. 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 ask a question",
+      parameters: [
+        {
+          name: "question",
+          value: "What is the name of the project?"
+        }
+      ]
+    },
+    {
+      description: "Request to ask a question with options",
+      parameters: [
+        {
+          name: "question",
+          value: "What framework do you use?"
+        },
+        {
+          name: "options",
+          value: "React,Angular,Vue,Svelte"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 0 /* None */
+};
+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\u2019s 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. This tool MUST NOT to be used with any other tool.",
+  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.",
+      required: true,
+      usageValue: "Your final result description here"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to present the result of the task",
+      parameters: [
+        {
+          name: "result",
+          value: "Your final result description here"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 0 /* None */
+};
+var handler2 = async (provider, args) => {
+  const result = getString(args, "result");
+  const moreMessage = await provider.attemptCompletion?.(result);
+  if (!moreMessage) {
+    return {
+      type: "Exit" /* Exit */,
+      message: result
+    };
+  }
+  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/delegate.ts
+var toolInfo3 = {
+  name: "delegate",
+  description: "Temporarily delegate a task to another agent and receive the result back. This tool MUST NOT to be used with any other tool.",
+  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"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 0 /* None */
+};
+var handler3 = async (_provider, args) => {
+  const agentName = getString(args, "agent_name");
+  const task = getString(args, "task");
+  const context = getString(args, "context", void 0);
+  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: [
+    {
+      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"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to execute a command",
+      parameters: [
+        {
+          name: "command",
+          value: "npm run dev"
+        },
+        {
+          name: "requires_approval",
+          value: "false"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 3 /* Arbitrary */
+};
+var handler4 = 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 isAvailable4 = (provider) => {
+  return !!provider.executeCommand;
+};
+var executeCommand_default = {
+  ...toolInfo4,
+  handler: handler4,
+  isAvailable: isAvailable4
+};
+
+// src/tools/listCodeDefinitionNames.ts
+var toolInfo5 = {
+  name: "list_code_definition_names",
+  description: "Request to list definition names (classes, functions, methods, etc.) used for all files in a 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 a code file to list top level source code definitions for.",
+      required: true,
+      usageValue: "Directory path here"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to list code definition names in a directory",
+      parameters: [
+        {
+          name: "path",
+          value: "src/utils"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 1 /* Read */
+};
+var handler5 = 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 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_result>
+${result}
+</list_code_definition_names_result>`
+  };
+};
+var isAvailable5 = (provider) => {
+  return !!provider.listCodeDefinitionNames;
+};
+var listCodeDefinitionNames_default = {
+  ...toolInfo5,
+  handler: handler5,
+  isAvailable: isAvailable5
+};
+
+// src/tools/listFiles.ts
+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: [
+    {
+      name: "path",
+      description: "The path of the directory to list contents for (relative to the current working directory)",
+      required: true,
+      usageValue: "Directory path here"
+    },
+    {
+      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: "true or false (optional)"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to list files",
+      parameters: [
+        {
+          name: "path",
+          value: "src"
+        },
+        {
+          name: "max_count",
+          value: "100"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 1 /* Read */
+};
+var handler6 = 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", 2e3);
+  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("\n")}
+</list_files_files>
+<list_files_truncated>${limitReached}</list_files_truncated>`
+  };
+};
+var isAvailable6 = (provider) => {
+  return !!provider.listFiles;
+};
+var listFiles_default = {
+  ...toolInfo6,
+  handler: handler6,
+  isAvailable: isAvailable6
+};
+
+// src/tools/readFile.ts
+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: [
+    {
+      name: "path",
+      description: "The path of the file to read",
+      required: true,
+      usageValue: "Comma separated paths here"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to read the contents of a file",
+      parameters: [
+        {
+          name: "path",
+          value: "src/main.js"
+        }
+      ]
+    },
+    {
+      description: "Request to read multiple files",
+      parameters: [
+        {
+          name: "path",
+          value: "src/main.js,src/index.js"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 1 /* Read */
+};
+var handler7 = 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);
+    const isEmpty = fileContent.trim().length === 0;
+    if (isEmpty) {
+      resp.push(`<read_file_file_content path="${path}" is_empty="true" />`);
+    } else {
+      resp.push(`<read_file_file_conten path="${path}">${fileContent}</read_file_file_content>`);
+    }
+  }
+  return {
+    type: "Reply" /* Reply */,
+    message: resp.join("\n")
+  };
+};
+var isAvailable7 = (provider) => {
+  return !!provider.readFile;
+};
+var readFile_default = {
+  ...toolInfo7,
+  handler: handler7,
+  isAvailable: isAvailable7
+};
+
+// src/tools/replaceInFile.ts
+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: [
+    {
+      name: "path",
+      description: "The path of the file to modify",
+      required: true,
+      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 replace sections of content in a file",
+      parameters: [
+        {
+          name: "path",
+          value: "src/main.js"
+        },
+        {
+          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
+`
+        }
+      ]
+    }
+  ],
+  permissionLevel: 2 /* Write */
+};
+var handler8 = async (provider, args) => {
+  if (!provider.readFile || !provider.writeFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to replace in file. Abort."
+    };
+  }
+  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 isAvailable8 = (provider) => {
+  return !!provider.readFile && !!provider.writeFile;
+};
+var replaceInFile_default = {
+  ...toolInfo8,
+  handler: handler8,
+  isAvailable: isAvailable8
+};
+
+// src/tools/searchFiles.ts
+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: [
+    {
+      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)"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to perform a regex search across files",
+      parameters: [
+        {
+          name: "path",
+          value: "src"
+        },
+        {
+          name: "regex",
+          value: "^components/"
+        },
+        {
+          name: "file_pattern",
+          value: "*.ts"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 1 /* Read */
+};
+var handler9 = async (provider, args) => {
+  if (!provider.searchFiles) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to search files. Abort."
+    };
+  }
+  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("\n")}
+</search_files_files>
+`
+  };
+};
+var isAvailable9 = (provider) => {
+  return !!provider.searchFiles;
+};
+var searchFiles_default = {
+  ...toolInfo9,
+  handler: handler9,
+  isAvailable: isAvailable9
+};
+
+// src/tools/writeToFile.ts
+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: [
+    {
+      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"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to write content to a file",
+      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;
+`
+        }
+      ]
+    }
+  ],
+  permissionLevel: 2 /* Write */
+};
+var handler10 = async (provider, args) => {
+  if (!provider.writeFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to write file. Abort."
+    };
+  }
+  const path = getString(args, "path");
+  const content = getString(args, "content");
+  await provider.writeFile(path, content);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<write_to_file_path>${path}</write_to_file_path><status>Success</status>`
+  };
+};
+var isAvailable10 = (provider) => {
+  return !!provider.writeFile;
+};
+var writeToFile_default = {
+  ...toolInfo10,
+  handler: handler10,
+  isAvailable: isAvailable10
+};
+
+// src/tools/handOver.ts
+var toolInfo11 = {
+  name: "hand_over",
+  description: "Hand over the current task to another agent to complete. This tool MUST NOT to be used with any other tool.",
+  parameters: [
+    {
+      name: "agent_name",
+      description: "The name of the agent to hand over 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: "Hand over a coding task to the coder agent",
+      parameters: [
+        {
+          name: "agent_name",
+          value: "coder"
+        },
+        {
+          name: "task",
+          value: "Implement the login feature"
+        },
+        {
+          name: "context",
+          value: "We need a secure login system with email and password"
+        },
+        {
+          name: "files",
+          value: "src/auth/login.ts,src/auth/types.ts"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 0 /* None */
+};
+var handler11 = async (_provider, args) => {
+  const agentName = getString(args, "agent_name");
+  const task = getString(args, "task");
+  const context = getString(args, "context", void 0);
+  const files = getStringArray(args, "files", []);
+  return {
+    type: "HandOver" /* HandOver */,
+    agentName,
+    task,
+    context,
+    files
+  };
+};
+var isAvailable11 = (_provider) => {
+  return true;
+};
+var handOver_default = {
+  ...toolInfo11,
+  handler: handler11,
+  isAvailable: isAvailable11
+};
+
+// src/tools/removeFile.ts
+var toolInfo12 = {
+  name: "remove_file",
+  description: "Request to remove a file at the specified path.",
+  parameters: [
+    {
+      name: "path",
+      description: "The path of the file to remove",
+      required: true,
+      usageValue: "File path here"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to remove a file",
+      parameters: [
+        {
+          name: "path",
+          value: "src/main.js"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 2 /* Write */
+};
+var handler12 = async (provider, args) => {
+  if (!provider.removeFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to remove file. Abort."
+    };
+  }
+  const path = getString(args, "path");
+  await provider.removeFile(path);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<remove_file_path>${path}</remove_file_path><status>Success</status>`
+  };
+};
+var isAvailable12 = (provider) => {
+  return !!provider.removeFile;
+};
+var removeFile_default = {
+  ...toolInfo12,
+  handler: handler12,
+  isAvailable: isAvailable12
+};
+
+// src/tools/renameFile.ts
+var toolInfo13 = {
+  name: "rename_file",
+  description: "Request to rename a file from source path to target path.",
+  parameters: [
+    {
+      name: "sourcePath",
+      description: "The current path of the file",
+      required: true,
+      usageValue: "Source file path here"
+    },
+    {
+      name: "targetPath",
+      description: "The new path for the file",
+      required: true,
+      usageValue: "Target file path here"
+    }
+  ],
+  examples: [
+    {
+      description: "Request to rename a file",
+      parameters: [
+        {
+          name: "sourcePath",
+          value: "src/old-name.js"
+        },
+        {
+          name: "targetPath",
+          value: "src/new-name.js"
+        }
+      ]
+    }
+  ],
+  permissionLevel: 2 /* Write */
+};
+var handler13 = async (provider, args) => {
+  if (!provider.renameFile) {
+    return {
+      type: "Error" /* Error */,
+      message: "Not possible to rename file. Abort."
+    };
+  }
+  const sourcePath = getString(args, "sourcePath");
+  const targetPath = getString(args, "targetPath");
+  await provider.renameFile(sourcePath, targetPath);
+  return {
+    type: "Reply" /* Reply */,
+    message: `<rename_file_path>${targetPath}</rename_file_path><status>Success</status>`
+  };
+};
+var isAvailable13 = (provider) => {
+  return !!provider.renameFile;
+};
+var renameFile_default = {
+  ...toolInfo13,
+  handler: handler13,
+  isAvailable: isAvailable13
+};
+
+// src/getAvailableTools.ts
+var getAvailableTools = ({
+  provider,
+  allTools,
+  hasAgent,
+  permissionLevel,
+  interactive
+}) => {
+  const filteredTools = interactive ? allTools : allTools.filter((tool) => tool.name !== askFollowupQuestion_default.name);
+  const tools = [];
+  for (const tool of filteredTools) {
+    if (!hasAgent) {
+      switch (tool.name) {
+        case handOver_default.name:
+        case delegate_default.name:
+          continue;
+      }
+    }
+    if (tool.isAvailable(provider) && tool.permissionLevel <= permissionLevel) {
+      tools.push(tool);
+    }
+  }
+  return tools;
+};
+
+// 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("|");
+  let remainingMessage = assistantMessage;
+  let match;
+  const tagRegex = new RegExp(`<(${toolPattern})>([\\s\\S]*?)<\\/\\1>`, "s");
+  while (true) {
+    match = tagRegex.exec(remainingMessage);
+    if (match === null) break;
+    const beforeTag = remainingMessage.slice(0, match.index).trim();
+    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);
+    const fullTagContent = match[0];
+    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
+      });
+    }
+    remainingMessage = remainingMessage.slice(match.index + fullTagContent.length);
+  }
+  if (remainingMessage.trim()) {
+    results.push({
+      type: "text",
+      content: remainingMessage.trim()
+    });
+  }
+  if (results.length === 0) {
+    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("\n")}
+
+Usage:
+<${toolNamePrefix}${tool.name}>
+${tool.parameters.map((param) => `<${parameterPrefix}${param.name}>${param.usageValue}</${parameterPrefix}${param.name}>`).join("\n")}
+</${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("\n")}
+</${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.
+
+NEVER surround tool use with triple backticks (\`\`\`).
+
+# Tools
+${tools.map((tool) => toolInfoPrompt(tool, toolNamePrefix, parameterPrefix)).join("\n")}
+
+# 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. **Thinking**: Use \`<thinking>\` XCM tag 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\u2019s 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\u2019s response after each tool use. Do not proceed until you have their confirmation. The user\u2019s 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.
+- You confirm each step\u2019s results before proceeding.
+- You provide only the necessary information in user-facing replies to prevent re-interpretation as new commands.`;
+};
+var agentsPrompt = (agents, name) => `
+====
+
+AVAILABLE AGENTS
+
+The following agents are available for task handover/delegate:
+${agents.map(
+  (agent) => `
+- **${agent.name}**
+  - Responsibilities:
+${agent.responsibilities.map((resp) => `    - ${resp}`).join("\n")}`
+).join("\n")}
+
+- **Current Agent Role**
+  You are currently acting as **${name}**. If you identify the task is beyond your current scope, use the handover or delegate tool to transition to the other agent. Include sufficient context so the new agent can seamlessly continue the work.
+`;
+var capabilities = (toolNamePrefix) => `
+====
+
+CAPABILITIES
+
+- You have access to a range of tools to aid you in your work. These tools help you effectively accomplish a wide range of tasks.
+- When the user initially gives you a task, a recursive list of all filepaths in the current working directory will be included in context. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further.`;
+var systemInformation = (info) => `
+====
+
+SYSTEM INFORMATION
+
+Operating System: ${info.os}`;
+var customInstructions = (customInstructions2) => {
+  const joined = customInstructions2.join("\n");
+  if (joined.trim() === "") {
+    return "";
+  }
+  return `
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+${joined}`;
+};
+var customScripts = (commands) => {
+  const joined = Object.entries(commands).map(([name, command]) => {
+    if (typeof command === "string") {
+      return `- ${name}
+  - Command: \`${command}\``;
+    }
+    return `- ${name}
+  - Command: \`${command.command}\`
+  - Description: ${command.description}`;
+  }).join("\n");
+  if (joined.trim() === "") {
+    return "";
+  }
+  return `
+====
+
+USER'S CUSTOM COMMANDS
+
+The following additional commands are provided by the user, and should be followed to the best of your ability without interfering with the TOOL USE guidelines.
+
+${joined}`;
+};
+var responsePrompts = {
+  errorInvokeTool: (tool, error) => `An error occurred while invoking the tool "${tool}": ${error}`,
+  requireUseTool: "Error: You MUST use a tool before proceeding using XCM tags. e.g. <tool_tool_name>tool_name</tool_tool_name>",
+  toolResults: (tool, result) => `<tool_response>
+<tool_name>${tool}</tool_name>
+<tool_result>
+${result}
+</tool_result>
+</tool_response>`,
+  commandResult: (command, exitCode, stdout, stderr) => `<command>${command}</command>
+<command_exit_code>${exitCode}</command_exit_code>
+<command_stdout>
+${stdout}
+</command_stdout>
+<command_stderr>
+${stderr}
+</command_stderr>`
+};
+
+// src/Agent/AgentBase.ts
+var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
+  TaskEventKind2["StartTask"] = "StartTask";
+  TaskEventKind2["StartRequest"] = "StartRequest";
+  TaskEventKind2["EndRequest"] = "EndRequest";
+  TaskEventKind2["Usage"] = "Usage";
+  TaskEventKind2["Text"] = "Text";
+  TaskEventKind2["Reasoning"] = "Reasoning";
+  TaskEventKind2["ToolUse"] = "ToolUse";
+  TaskEventKind2["ToolReply"] = "ToolReply";
+  TaskEventKind2["ToolInvalid"] = "ToolInvalid";
+  TaskEventKind2["ToolError"] = "ToolError";
+  TaskEventKind2["ToolInterrupted"] = "ToolInterrupted";
+  TaskEventKind2["ToolHandOver"] = "ToolHandOver";
+  TaskEventKind2["ToolDelegate"] = "ToolDelegate";
+  TaskEventKind2["UsageExceeded"] = "UsageExceeded";
+  TaskEventKind2["EndTask"] = "EndTask";
+  return TaskEventKind2;
+})(TaskEventKind || {});
+var AgentBase = class {
+  ai;
+  config;
+  handlers;
+  messages = [];
+  constructor(name, ai, config) {
+    this.ai = ai;
+    if (config.agents && config.agents.length > 0) {
+      const agents = agentsPrompt(config.agents, name);
+      config.systemPrompt += `
+${agents}`;
+    }
+    this.config = config;
+    const handlers = {};
+    for (const tool of config.tools) {
+      handlers[tool.name] = tool;
+    }
+    this.handlers = handlers;
+  }
+  async #callback(event) {
+    await this.config.callback?.(event);
+  }
+  async startTask({ task, context }) {
+    let text = `<task>${task}</task>`;
+    if (context) {
+      text += `
+<context>${context}</context>`;
+    }
+    this.#callback({ kind: "StartTask" /* StartTask */, agent: this, systemPrompt: this.config.systemPrompt });
+    return await this.#processLoop(text);
+  }
+  async #processLoop(userMessage) {
+    let nextRequest = userMessage;
+    while (true) {
+      if (this.ai.usageMeter.isLimitExceeded().result) {
+        this.#callback({ kind: "UsageExceeded" /* UsageExceeded */, agent: this });
+        return { type: "UsageExceeded" };
+      }
+      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 = resp.replay;
+    }
+  }
+  async continueTask(userMessage) {
+    return await this.#processLoop(userMessage);
+  }
+  async #request(userMessage) {
+    if (!userMessage) {
+      throw new Error("userMessage is missing");
+    }
+    await this.#callback({ kind: "StartRequest" /* StartRequest */, agent: this, userMessage });
+    this.messages.push({
+      role: "user",
+      content: userMessage
+    });
+    let currentAssistantMessage = "";
+    const retryCount = 5;
+    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");
+    }
+    this.messages.push({
+      role: "assistant",
+      content: currentAssistantMessage
+    });
+    const ret = parseAssistantMessage(currentAssistantMessage, this.config.tools, this.config.toolNamePrefix);
+    await this.#callback({ kind: "EndRequest" /* EndRequest */, agent: this });
+    return ret;
+  }
+  async #handleResponse(response) {
+    const toolReponses = [];
+    outer: for (const content of response) {
+      switch (content.type) {
+        case "text":
+          break;
+        case "tool_use": {
+          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 this.#callback({ kind: "ToolReply" /* ToolReply */, agent: this, tool: content.name });
+              toolReponses.push({ tool: content.name, response: toolResp.message });
+              break;
+            case "Exit" /* Exit */:
+              if (toolReponses.length > 0) {
+                break outer;
+              }
+              return { exit: toolResp };
+            case "Invalid" /* Invalid */:
+              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 this.#callback({ kind: "ToolError" /* ToolError */, agent: this, tool: content.name });
+              toolReponses.push({ tool: content.name, response: toolResp.message });
+              break outer;
+            case "Interrupted" /* Interrupted */:
+              await this.#callback({ kind: "ToolInterrupted" /* ToolInterrupted */, agent: this, tool: content.name });
+              return { exit: toolResp };
+            case "HandOver" /* HandOver */:
+              if (toolReponses.length > 0) {
+                break outer;
+              }
+              await this.#callback({
+                kind: "ToolHandOver" /* ToolHandOver */,
+                agent: this,
+                tool: content.name,
+                agentName: toolResp.agentName,
+                task: toolResp.task,
+                context: toolResp.context,
+                files: toolResp.files
+              });
+              return { exit: toolResp };
+            case "Delegate" /* Delegate */:
+              if (toolReponses.length > 0) {
+                continue;
+              }
+              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) {
+      return { replay: responsePrompts.requireUseTool };
+    }
+    const finalResp = toolReponses.map(({ tool, response: response2 }) => responsePrompts.toolResults(tool, response2)).join("\n\n");
+    return { replay: finalResp };
+  }
+  async #invokeTool(name, args) {
+    try {
+      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(this.handlers[name].name, args);
+      if (resp) {
+        return resp;
+      }
+      return await handler14(this.config.provider, args);
+    } catch (error) {
+      return {
+        type: "Error" /* Error */,
+        message: responsePrompts.errorInvokeTool(name, error),
+        canRetry: false
+      };
+    }
+  }
+  get model() {
+    return this.ai.model;
+  }
+  get usage() {
+    return this.ai.usageMeter.usage;
+  }
+};
+
+// src/Agent/AnalyzerAgent/prompts.ts
+var fullSystemPrompt = (info, tools, toolNamePrefix, instructions, scripts) => `
+# Analyzer Agent
+
+## Role
+You are the **Analyzer** agent, responsible for:
+1. **Project Structure Analysis** \u2013 Understand codebase organization and architecture.
+2. **Code Pattern Analysis** \u2013 Identify common patterns, conventions, and best practices.
+3. **Dependency Analysis** \u2013 Examine project dependencies and their usage.
+4. **Workflow Analysis** \u2013 Understand development tools, scripts, and processes.
+5. **Documentation Review** \u2013 Analyze documentation and code comments.
+
+> **Note**: The **Analyzer** agent focuses on understanding and analyzing the codebase without making modifications. Your role is to provide insights and understanding that can inform development decisions.
+
+## Rules
+1. **Thoroughness**: Conduct comprehensive analysis of relevant project aspects.
+2. **Pattern Recognition**: Identify recurring patterns, conventions, and architectural decisions.
+3. **Dependency Mapping**: Track and understand relationships between components.
+4. **Workflow Understanding**: Analyze build processes, testing approaches, and development tools.
+5. **Documentation Assessment**: Review documentation quality and completeness.
+6. **Non-Modification**: Never modify code or files - focus solely on analysis.
+
+${toolUsePrompt(tools, toolNamePrefix)}
+${capabilities(toolNamePrefix)}
+${systemInformation(info)}
+${customInstructions(instructions)}
+${customScripts(scripts)}
+`;
+
+// src/Agent/AnalyzerAgent/index.ts
+var AnalyzerAgent = class extends AgentBase {
+  constructor(options) {
+    const combinedTools = [...options.additionalTools ?? [], ...Object.values(allTools_exports)];
+    const tools = getAvailableTools({
+      provider: options.provider,
+      allTools: combinedTools,
+      hasAgent: (options.agents?.length ?? 0) > 0,
+      permissionLevel: 1 /* Read */,
+      interactive: true
+    });
+    const toolNamePrefix = "tool_";
+    const systemPrompt = fullSystemPrompt(
+      {
+        os: options.os
+      },
+      tools,
+      toolNamePrefix,
+      options.customInstructions ?? [],
+      options.scripts ?? {}
+    );
+    super(analyzerAgentInfo.name, options.ai, {
+      systemPrompt,
+      tools,
+      toolNamePrefix,
+      provider: options.provider,
+      interactive: options.interactive,
+      agents: options.agents,
+      scripts: options.scripts,
+      callback: options.callback
+    });
+  }
+  onBeforeInvokeTool() {
+    return Promise.resolve(void 0);
+  }
+};
+var analyzerAgentInfo = {
+  name: "analyzer",
+  responsibilities: [
+    "Analyzing project structure and organization",
+    "Identifying key source code files and their relationships",
+    "Understanding common coding patterns and conventions",
+    "Examining development workflow and tooling",
+    "Analyzing dependencies and their usage patterns"
+  ]
+};
+
+// src/Agent/ArchitectAgent/prompts.ts
+var fullSystemPrompt2 = (info, tools, toolNamePrefix, instructions, scripts) => `
+# Architect Agent
+
+## Role
+You are the **Architect** agent, responsible for:
+1. **Task Analysis** \u2013 Understand requirements.
+2. **File Identification** \u2013 Find and select relevant files.
+3. **File Reading** \u2013 Use the provided tools to gather information from these files.
+4. **Implementation Plan** \u2013 Draft a concise plan detailing steps, resources, and dependencies.
+5. **Review & Improve** \u2013 Evaluate and refine the plan.
+6. **Handover/Delegate** \u2013 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.
+
+## Rules
+1. **Consistency**: Maintain alignment with the user\u2019s instructions and the system\u2019s objectives at all times.
+2. **Relevance**: Only read and use files directly related to the task. Avoid unnecessary or tangential information.
+3. **Conciseness**: Keep all communications and plans succinct, avoiding superfluous or repetitive details.
+4. **Accuracy**: Ensure the information you gather and any conclusions you draw are correct and verifiable.
+5. **Clarity**: Present the final plan and any supporting details in a structured and easily understandable format.
+6. **Minimal Queries**: Ask clarifying questions only when essential, and avoid repeated questioning that does not add value.
+
+## Steps
+1. **Analyze Task**
+   - Gather and understand the user\u2019s requirements.
+   - Note any potential constraints or objectives that may influence the plan.
+
+2. **Identify Relevant Files**
+   - Determine which files or documents are necessary.
+   - Justify why these files are relevant.
+
+3. **Read Files via Tools**
+   - Utilize the provided tools to access and extract information from the identified files.
+   - Summarize key insights or data for the solution.
+
+4. **Create Implementation Plan**
+   - Outline tasks, define milestones, and detail resources or dependencies.
+   - Provide clear, concise instructions for each step.
+   - Each step should be appropriate sized and self-contained.
+
+5. **Handover/Delegate**
+   - Evaluate the number of steps required.
+   - Handleover to the **Coder** agent if only one step is required.
+   - If multiple steps are required, delegate each step to the **Coder** agent.
+   - 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)}
+${capabilities(toolNamePrefix)}
+${systemInformation(info)}
+${customInstructions(instructions)}
+${customScripts(scripts)}
+`;
+
+// src/Agent/ArchitectAgent/index.ts
+var ArchitectAgent = class extends AgentBase {
+  constructor(options) {
+    const combinedTools = [...options.additionalTools ?? [], ...Object.values(allTools_exports)];
+    const tools = getAvailableTools({
+      provider: options.provider,
+      allTools: combinedTools,
+      hasAgent: (options.agents?.length ?? 0) > 0,
+      permissionLevel: 1 /* Read */,
+      interactive: true
+    });
+    const toolNamePrefix = "tool_";
+    const systemPrompt = fullSystemPrompt2(
+      {
+        os: options.os
+      },
+      tools,
+      toolNamePrefix,
+      options.customInstructions ?? [],
+      options.scripts ?? {}
+    );
+    super(architectAgentInfo.name, options.ai, {
+      systemPrompt,
+      tools,
+      toolNamePrefix,
+      provider: options.provider,
+      interactive: options.interactive,
+      agents: options.agents,
+      scripts: options.scripts,
+      callback: options.callback
+    });
+  }
+  onBeforeInvokeTool() {
+    return Promise.resolve(void 0);
+  }
+};
+var architectAgentInfo = {
+  name: "architect",
+  responsibilities: [
+    "Analyzing the user\u2019s overall task and requirements.",
+    "Creating plans and making higher-level decisions about system structure and design.",
+    "Reviewing and analyzing existing code or components for maintainability and scalability.",
+    "Laying out the roadmap for implementation."
+  ]
+};
+
+// 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)}`;
+
+// src/Agent/CodeFixerAgent/index.ts
+var CodeFixerAgent = class extends AgentBase {
+  #maxRetries;
+  #retryCount = 0;
+  constructor(options) {
+    const combinedTools = [...options.additionalTools ?? [], ...Object.values(allTools_exports)];
+    const tools = getAvailableTools({
+      provider: options.provider,
+      allTools: combinedTools,
+      hasAgent: (options.agents?.length ?? 0) > 0,
+      permissionLevel: 3 /* Arbitrary */,
+      interactive: true
+    });
+    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 basePrompt2 = "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.";
+var editingFilesPrompt = (toolNamePrefix) => `
+====
+
+EDITING FILES
+
+You have access to two tools for working with files: **${toolNamePrefix}write_to_file** and **${toolNamePrefix}replace_in_file**. Understanding their roles and selecting the right one for the job will help ensure efficient and accurate modifications.
+
+# ${toolNamePrefix}write_to_file
+
+## Purpose
+
+- Create a new file, or overwrite the entire contents of an existing file.
+
+## When to Use
+
+- Initial file creation, such as when scaffolding a new project.
+- Overwriting large boilerplate files where you want to replace the entire content at once.
+- When the complexity or number of changes would make ${toolNamePrefix}replace_in_file unwieldy or error-prone.
+- When you need to completely restructure a file's content or change its fundamental organization.
+
+## Important Considerations
+
+- Using ${toolNamePrefix}write_to_file requires providing the file\u2019s complete final content.
+- If you only need to make small changes to an existing file, consider using ${toolNamePrefix}replace_in_file instead to avoid unnecessarily rewriting the entire file.
+- While ${toolNamePrefix}write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
+
+# ${toolNamePrefix}replace_in_file
+
+## Purpose
+
+- Make targeted edits to specific parts of an existing file without overwriting the entire file.
+
+## When to Use
+
+- Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
+- Targeted improvements where only specific portions of the file\u2019s content needs to be altered.
+- Especially useful for long files where much of the file will remain unchanged.
+
+## Advantages
+
+- More efficient for minor edits, since you don\u2019t need to supply the entire file content.
+- Reduces the chance of errors that can occur when overwriting large files.
+
+# Choosing the Appropriate Tool
+
+- **Default to ${toolNamePrefix}replace_in_file** for most changes. It's the safer, more precise option that minimizes potential issues.
+- **Use ${toolNamePrefix}write_to_file** when:
+  - Creating new files
+  - The changes are so extensive that using ${toolNamePrefix}replace_in_file would be more complex or risky
+  - You need to completely reorganize or restructure a file
+  - The file is relatively small and the changes affect most of its content
+  - You're generating boilerplate or template files
+
+# Workflow Tips
+
+1. Before editing, assess the scope of your changes and decide which tool to use.
+2. For targeted edits, apply ${toolNamePrefix}replace_in_file with carefully crafted SEARCH/REPLACE blocks. If you need multiple changes, you can stack multiple SEARCH/REPLACE blocks within a single ${toolNamePrefix}replace_in_file call.
+3. For major overhauls or initial file creation, rely on ${toolNamePrefix}write_to_file.
+4. Once the file has been edited with either ${toolNamePrefix}write_to_file or ${toolNamePrefix}replace_in_file, the system will provide you with the final state of the modified file. Use this updated content as the reference point for any subsequent SEARCH/REPLACE operations, since it reflects any auto-formatting or user-applied changes.
+
+By thoughtfully selecting between ${toolNamePrefix}write_to_file and ${toolNamePrefix}replace_in_file, you can make your file editing process smoother, safer, and more efficient.`;
+var rules = (toolNamePrefix) => `
+====
+
+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 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.
+- When creating a new project (such as an app, website, or any software project), organize all new files within a dedicated project directory unless the user specifies otherwise. Use appropriate file paths when creating files, as the ${toolNamePrefix}write_to_file tool will automatically create any necessary directories. Structure the project logically, adhering to best practices for the specific type of project being created. Unless otherwise specified, new projects should be easily run without additional setup, for example most projects can be built in HTML, CSS, and JavaScript - which you can open in a browser.
+- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
+- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
+- **Adhere to any established coding style, linting rules, or naming conventions if they are known or can be inferred from the existing codebase, to maintain consistency.**
+- When you want to modify a file, use the ${toolNamePrefix}replace_in_file or ${toolNamePrefix}write_to_file tool directly with the desired changes. You do not need to display the changes before using the tool.
+- **Do not guess or hallucinate file content that has not been explicitly provided or read. Always read an existing file with \`${toolNamePrefix}read_file\` (or rely on content the user directly provided) before modifying it, unless you are creating a brand-new file.**
+- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the ${toolNamePrefix}attempt_completion tool to present the result to the user.
+- The user may provide a file's contents directly in their message, in which case you shouldn't use the ${toolNamePrefix}read_file tool to get the file contents again since you already have it.
+- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.
+- NEVER end ${toolNamePrefix}attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
+- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
+- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
+- When using the ${toolNamePrefix}replace_in_file tool, you must include complete lines in your SEARCH blocks, not partial lines. The system requires exact line matches and cannot match partial lines. For example, if you want to match a line containing "const x = 5;", your SEARCH block must include the entire line, not just "x = 5" or other fragments.
+- When using the ${toolNamePrefix}replace_in_file tool, if you use multiple SEARCH/REPLACE blocks, list them in the order they appear in the file. For example if you need to make changes to both line 10 and line 50, first include the SEARCH/REPLACE block for line 10, followed by the SEARCH/REPLACE block for line 50.
+- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.
+- Keep the inline docs up to date if needed.
+`;
+var objectives = (toolNamePrefix) => `
+====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+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 fullSystemPrompt4 = (info, tools, toolNamePrefix, instructions, scripts) => `
+${basePrompt2}
+${toolUsePrompt(tools, toolNamePrefix)}
+${editingFilesPrompt(toolNamePrefix)}
+${capabilities(toolNamePrefix)}
+${rules(toolNamePrefix)}
+${objectives(toolNamePrefix)}
+${systemInformation(info)}
+${customInstructions(instructions)}
+${customScripts(scripts)}
+`;
+
+// src/Agent/CoderAgent/index.ts
+var CoderAgent = class extends AgentBase {
+  constructor(options) {
+    const combinedTools = [...options.additionalTools ?? [], ...Object.values(allTools_exports)];
+    const tools = getAvailableTools({
+      provider: options.provider,
+      allTools: combinedTools,
+      hasAgent: (options.agents?.length ?? 0) > 0,
+      permissionLevel: 3 /* Arbitrary */,
+      interactive: true
+    });
+    const toolNamePrefix = "tool_";
+    const systemPrompt = fullSystemPrompt4(
+      {
+        os: options.os
+      },
+      tools,
+      toolNamePrefix,
+      options.customInstructions ?? [],
+      options.scripts ?? {}
+    );
+    super(coderAgentInfo.name, options.ai, {
+      systemPrompt,
+      tools,
+      toolNamePrefix,
+      provider: options.provider,
+      interactive: options.interactive,
+      agents: options.agents,
+      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;
+    }
+    const format = this.config.scripts?.format;
+    const formatCommand = typeof format === "string" ? format : format?.command;
+    if (formatCommand) {
+      try {
+        await executeCommand(formatCommand, false);
+      } catch (error) {
+        console.warn(`Failed to format code using command: ${formatCommand}`, error);
+      }
+    }
+    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 coderAgentInfo = {
+  name: "coder",
+  responsibilities: [
+    "Editing and refactoring existing code.",
+    "Creating new features or modules.",
+    "Running tests and analyzing test results.",
+    "Maintaining coding standards, lint rules, and general code quality."
+  ]
+};
+
+// src/Agent/MultiAgent.ts
+var MultiAgent = class {
+  #config;
+  #agents = [];
+  constructor(config) {
+    this.#config = config;
+  }
+  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) {
+    const newAgent = await this.#config.createAgent(agentName);
+    this.#agents.push(newAgent);
+    const exitReason = await newAgent.startTask({
+      task,
+      context
+    });
+    return await this.#handleTaskResult(exitReason);
+  }
+  async startTask(options) {
+    if (this.#agents.length > 0) {
+      throw new Error("An active agent already exists");
+    }
+    return this.#startTask(options.agentName, options.task, options.context);
+  }
+  async continueTask(userMessage) {
+    if (!this.#agents.length) {
+      throw new Error("No active agent");
+    }
+    const exitReason = await this.#agents[this.#agents.length - 1].continueTask(userMessage);
+    return await this.#handleTaskResult(exitReason);
+  }
+  get hasActiveAgent() {
+    return this.#agents.length > 0;
+  }
+};
+
+// src/Agent/index.ts
+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:
+
+1. **Gather Information:**
+   - Begin by asking the user for essential project details, including:
+     - Project type (e.g., web, mobile, desktop, etc.)
+     - Desired programming languages
+     - Preferred frameworks or libraries
+     - Build tools and package manager preferences
+     - Testing frameworks and patterns
+     - Code style and linting preferences
+     - Any additional specifications or requirements
+
+2. **Clarification & Confirmation:**
+   - Do not make any decisions or assumptions on behalf of the user.
+   - Ask clarifying questions if any detail is ambiguous.
+   - Confirm each piece of information with the user before proceeding to the next step.
+
+3. **Avoid Redundancy:**
+   - Do not repeat questions or details that have already been confirmed.
+   - Keep interactions concise and focused on gathering complete and accurate details.
+
+4. **Generate Configuration:**
+   - Based on the collected information, generate a .polkacodes.yml configuration file that includes:
+     - scripts section with common development commands (test, format, check, etc.)
+     - rules section reflecting project conventions and tools
+     - excludeFiles section for sensitive files only
+   - Example structure:
+     \`\`\`yaml
+     scripts:
+       test:
+         command: "[test-command]"
+         description: "Run tests"
+       format:
+         command: "[format-command]"
+         description: "Format code"
+       check:
+         command: "[check-command]"
+         description: "Check code"
+
+     rules:
+       - "[package-manager-rule]"
+       - "[testing-framework-rule]"
+       - "[code-style-rule]"
+       - "[other-rule]"
+
+     excludeFiles:
+       - ".env"
+       - ".env.*"
+     \`\`\`
+
+5. **Generate Essential Project Files:**
+   - Create a .gitattributes file with appropriate configurations:
+     - Mark lock files as generated and exclude them from diffs
+     - Example for different package managers:
+       
+       # For Bun
+       bun.lock linguist-generated=true
+       bun.lock -diff
+       
+       # For npm
+       package-lock.json linguist-generated=true
+       package-lock.json -diff
+       
+       # For Yarn
+       yarn.lock linguist-generated=true
+       yarn.lock -diff
+       
+       # For pnpm
+       pnpm-lock.yaml linguist-generated=true
+       pnpm-lock.yaml -diff
+       
+     - Include other common configurations as needed based on project type
+
+6. **Handover to Coder Agent:**
+   - Once all required information is collected and validated by the user, compile:
+     1. The final project specifications
+     2. The .polkacodes.yml configuration content
+   - Clearly hand over these details to the coder agent, instructing them to:
+     1. Create the new project based on the confirmed specifications
+     2. Include the .polkacodes.yml file in the project root
+     3. Include the .gitattributes file with appropriate configurations
+     4. Ensure all specified tools and configurations are properly set up`;
+var createNewProject_default = {
+  name: "createNewProject",
+  description: "Creates a new project",
+  prompt,
+  formatInput: (params) => {
+    return `<project_name>${params}</project_name>`;
+  },
+  parseOutput: (output) => {
+    return output.trim();
+  },
+  agent: "architect"
+};
+
+// src/AiTool/generateGitCommitMessage.ts
+var prompt2 = `
+You are an advanced assistant specialized in creating concise and accurate Git commit messages. When you receive:
+- A Git diff inside the <tool_input> tag.
+- Additional user-supplied context inside the <tool_input_context> tag (if any).
+
+You will produce a single commit message enclosed within <tool_output> tags. The commit message must accurately reflect the changes shown in the diff and should be clear, descriptive, and devoid of unnecessary or repeated information. If a context is provided, it MUST be incorporated into the commit message.
+
+Here\u2019s an example of the input and the expected output format:
+
+<tool_input>
+--- a/example_file.py
++++ b/example_file.py
+@@ -10,7 +10,7 @@ def example_function():
+-    print("Old behavior")
++    print("New behavior")
+</tool_input>
+<tool_input_context>
+Changing print statement to update the user-facing message.
+</tool_input_context>
+
+Example Output:
+
+<tool_output>
+Update print statement for revised user-facing message
+</tool_output>
+
+Follow the same structure for any new input. Never repeat questions; focus on generating a concise commit message that captures the essence of the changes.
+`;
+var generateGitCommitMessage_default = {
+  name: "generateGitCommitMessage",
+  description: "Generates git commit messages from git diff output",
+  prompt: prompt2,
+  formatInput: (params) => {
+    let ret = `<tool_input>
+${params.diff}
+</tool_input>`;
+    if (params.context) {
+      ret += `
+<tool_input_context>
+${params.context}
+</tool_input_context>`;
+    }
+    return ret;
+  },
+  parseOutput: (output) => {
+    const regex = /<tool_output>([\s\S]*)<\/tool_output>/gm;
+    const match = regex.exec(output);
+    if (match) {
+      return match[1];
+    }
+    throw new Error(`Could not parse output:
+${output}`);
+  }
+};
+
+// src/AiTool/generateGithubPullRequestDetails.ts
+var prompt3 = `
+# Generate Github Pull Request Details
+
+You are given:
+- A branch name in <tool_input_branch_name>.
+- An optional context message in <tool_input_context> (which may or may not be present).
+- All commit messages combined in <tool_input_commit_messages>.
+- All diffs combined in <tool_input_commit_diff>.
+
+Your task:
+1. Consider the optional context (if provided).
+   - If an issue number is found, add "Closes #xxx" at the beginning of the PR description
+   - IMPORTANT: Use ONLY the exact format "Closes #xxx" at the beginning of the description
+   - DO NOT use variations like "Closes issue #xxx" or other formats
+2. Analyze the combined commit messages and diffs.
+3. Produce a single GitHub Pull Request title.
+4. Produce a Pull Request description that explains the changes.
+
+Use the following template for the Pull Request description:
+
+---
+**Context (if provided)**:
+- Acknowledge any guiding concerns or instructions.
+
+**Summary of Changes**:
+- Provide a concise list or overview of what changed.
+
+**Highlights of Changed Code**:
+- Mention only the specific sections or functionalities updated, without showing full surrounding context.
+
+**Additional Information (if needed)**:
+- Testing steps (if applicable).
+- Any notes or caveats.
+
+---
+
+Output format:
+<tool_output>
+  <tool_output_pr_title>YOUR PR TITLE HERE</tool_output_pr_title>
+  <tool_output_pr_description>
+    YOUR PR DESCRIPTION HERE
+  </tool_output_pr_description>
+</tool_output>
+
+Below is an **example** of the input and output:
+
+Example Input:
+<tool_input>
+<tool_input_branch_name>feature/refactor-logging</tool_input_branch_name>
+<tool_input_context>Implementing changes for issue #123 - Focus on clean code and maintainability</tool_input_context>
+<tool_input_commit_messages>
+Remove debug logs
+Refactor order validation logic
+</tool_input_commit_messages>
+<tool_input_commit_diff>
+diff --git a/user_service.py b/user_service.py
+- print("Debug info")
++ # Removed debug print statements
+
+diff --git a/order_service.py b/order_service.py
+- if is_valid_order(order):
+-     process_order(order)
++ validate_and_process(order)
+</tool_input_commit_diff>
+</tool_input>
+
+Example Output:
+<tool_output>
+<tool_output_pr_title>Refactor Order Validation and Remove Debug Logs</tool_output_pr_title>
+<tool_output_pr_description>
+closes #123
+
+This PR removes unnecessary debug print statements and updates order validation
+to use the new validate_and_process method for improved maintainability.
+</tool_output_pr_description>
+</tool_output>
+
+---
+
+Use the above format whenever you receive <tool_input> that may include a branch name, an optional context, aggregated commit messages in a single tag, and a combined diff in a single tag. Provide your final output strictly in <tool_output> with <tool_output_pr_title> and <tool_output_pr_description>. Only highlight the changed code and avoid including the context around the changes in the description.
+`;
+var generateGithubPullRequestDetails_default = {
+  name: "generateGithubPullRequestDetails",
+  description: "Generates a GitHub pull request title and description from git commits",
+  prompt: prompt3,
+  formatInput: (params) => {
+    return `<tool_input>
+<tool_input_branch_name>${params.branchName}</tool_input_branch_name>${params.context ? `
+<tool_input_context>${params.context}</tool_input_context>` : ""}
+<tool_input_commit_messages>${params.commitMessages}</tool_input_commit_messages>
+<tool_input_commit_diff>${params.commitDiff}</tool_input_commit_diff>
+</tool_input>`;
+  },
+  parseOutput: (output) => {
+    const regex = /<tool_output>([\s\S]*)<\/tool_output>/gm;
+    const match = regex.exec(output);
+    if (!match) {
+      throw new Error(`Could not parse output:
+${output}`);
+    }
+    const [, outputContent] = match;
+    const titleRegex = /<tool_output_pr_title>([\s\S]*)<\/tool_output_pr_title>/gm;
+    const titleMatch = titleRegex.exec(outputContent);
+    const descriptionRegex = /<tool_output_pr_description>([\s\S]*)<\/tool_output_pr_description>/gm;
+    const descriptionMatch = descriptionRegex.exec(outputContent);
+    if (titleMatch && descriptionMatch) {
+      return {
+        title: titleMatch[1],
+        description: descriptionMatch[1]
+      };
+    }
+    throw new Error(`Could not parse output:
+${output}`);
+  }
+};
+
+// src/AiTool/generateProjectConfig.ts
+var prompt4 = `You are an analyzer agent responsible for examining project files and generating appropriate polkacodes configuration. Your task is to:
+
+1. Read and analyze the provided files using tool_read_file to understand:
+   - Build tools and package manager (e.g., bun, npm)
+   - Testing frameworks and patterns
+   - Code style tools and rules
+   - Project structure and conventions
+   - Common development workflows
+
+2. Generate a YAML configuration that captures:
+   - scripts section based on package.json scripts and CI workflows. If applicable, generate following scripts:
+     - format: Format the code using a code formatter tool
+     - check: Check the code for errors using a linter tool
+     - test: Run tests using a test runner tool
+   - include other relevant scripts based on project conventions, tools, and patterns
+   - rules section based on project conventions, tools, and patterns
+   - excludeFiles section for sensitive files
+
+3. Use tool_attempt_completion to return the final configuration in this format:
+
+<tool_attempt_completion>
+<tool_parameter_result>
+scripts:
+  test:
+    command: "bun test"
+    description: "Run tests with bun:test"
+  lint:
+    command: "biome check ."
+    description: "Check code style with Biome"
+
+rules:
+  - "Use \`bun\` as package manager"
+  - "Write tests using bun:test with snapshots"
+  - "Follow Biome code style"
+
+excludeFiles:
+  # Sensitive files
+  - ".env"
+  - ".env.*"
+  - ".npmrc"
+</tool_parameter_result>
+</tool_attempt_completion>
+
+Focus on:
+- Package manager and dependency management
+- Testing frameworks and patterns
+- Code style and linting rules
+- File organization and naming conventions
+- Build and development workflows
+- Sensitive files that should not be committed:
+  - Environment files (.env*)
+  - Configuration files with potential secrets
+- Generated files to exclude:
+  - Lock files from package managers
+  - Build artifacts and outputs
+  - Generated file that are not ignored by .gitignore
+
+The configuration should accurately reflect the project's structure, tools, and conventions.
+`;
+var generateProjectConfig_default = {
+  name: "generateProjectConfig",
+  description: "Analyzes project files to generate polkacodes config sections",
+  prompt: prompt4,
+  formatInput: () => {
+    return "";
+  },
+  parseOutput: (output) => {
+    return output;
+  },
+  agent: "analyzer"
+};
+
+// src/AiTool/index.ts
+var executeTool = async (definition, ai, params) => {
+  const { response, usage } = await ai.request(definition.prompt, [
+    { role: "user", content: definition.formatInput(params) }
+  ]);
+  return {
+    response: definition.parseOutput(response),
+    usage
+  };
+};
+var executeAgentTool = async (definition, agent, params) => {
+  if (!definition.agent) {
+    throw new Error("Agent not specified");
+  }
+  const exitReason = await agent.startTask({
+    agentName: definition.agent,
+    task: definition.prompt,
+    context: definition.formatInput(params)
+  });
+  if (exitReason.type === "Exit" /* Exit */) {
+    return definition.parseOutput(exitReason.message);
+  }
+  throw new Error(`Tool execution failed: ${exitReason.type}`);
+};
+var makeTool = (definition) => {
+  return async (ai, params) => {
+    return executeTool(definition, ai, params);
+  };
+};
+var makeAgentTool = (definition) => {
+  return async (agent, params) => {
+    return executeAgentTool(definition, agent, params);
+  };
+};
+var generateGitCommitMessage = makeTool(generateGitCommitMessage_default);
+var generateGithubPullRequestDetails = makeTool(generateGithubPullRequestDetails_default);
+var generateProjectConfig = makeAgentTool(generateProjectConfig_default);
+var createNewProject = makeAgentTool(createNewProject_default);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentBase,
+  AiServiceProvider,
+  AnalyzerAgent,
+  ArchitectAgent,
+  CodeFixerAgent,
+  CoderAgent,
+  MockProvider,
+  MultiAgent,
+  PermissionLevel,
+  TaskEventKind,
+  ToolResponseType,
+  UsageMeter,
+  allAgents,
+  allTools,
+  analyzerAgentInfo,
+  anthropicDefaultModelId,
+  anthropicModels,
+  architectAgentInfo,
+  askFollowupQuestion,
+  attemptCompletion,
+  codeFixerAgentInfo,
+  coderAgentInfo,
+  createNewProject,
+  createService,
+  deepSeekDefaultModelId,
+  deepSeekModels,
+  defaultModels,
+  delegate,
+  executeAgentTool,
+  executeCommand,
+  executeTool,
+  generateGitCommitMessage,
+  generateGithubPullRequestDetails,
+  generateProjectConfig,
+  getAvailableTools,
+  handOver,
+  listCodeDefinitionNames,
+  listFiles,
+  makeAgentTool,
+  makeTool,
+  modelInfos,
+  openAiModelInfoSaneDefaults,
+  readFile,
+  removeFile,
+  renameFile,
+  replaceInFile,
+  searchFiles,
+  writeToFile
+});