@polka-codes/core 0.8.28 → 0.9.0

package/dist/index.js

@@ -4,865 +4,142 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/AiService/AiServiceBase.ts
-var AiServiceBase = class {
-  usageMeter;
-  options;
-  #abortController;
-  constructor(options) {
-    this.options = options;
-    this.usageMeter = options.usageMeter;
-  }
-  abort() {
-    this.#abortController?.abort();
-  }
-  async *send(systemPrompt, messages) {
-    this.usageMeter.checkLimit();
-    this.usageMeter.incrementMessageCount();
-    this.#abortController = new AbortController();
-    const stream = this.sendImpl(systemPrompt, messages, this.#abortController.signal);
-    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.checkLimit();
-    this.usageMeter.incrementMessageCount();
-    this.#abortController = new AbortController();
-    const stream = this.sendImpl(systemPrompt, messages, this.#abortController.signal);
-    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/AnthropicService.ts
-import { Anthropic } from "@anthropic-ai/sdk";
-
-// src/AiService/ModelInfo.ts
-var anthropicDefaultModelId = "claude-3-7-sonnet-20250219";
-var anthropicModels = {
-  "claude-opus-4-20250514": {
-    maxTokens: 32e3,
-    contextWindow: 2e5,
-    supportsImages: true,
-    supportsComputerUse: true,
-    supportsPromptCache: true,
-    inputPrice: 15,
-    outputPrice: 75,
-    cacheWritesPrice: 18.75,
-    cacheReadsPrice: 1.5,
-    reasoning: true
-  },
-  "claude-sonnet-4-20250514": {
-    maxTokens: 64e3,
-    contextWindow: 2e5,
-    supportsImages: true,
-    supportsComputerUse: true,
-    supportsPromptCache: true,
-    inputPrice: 3,
-    outputPrice: 15,
-    cacheWritesPrice: 3.75,
-    cacheReadsPrice: 0.3,
-    reasoning: true
-  },
-  "claude-3-7-sonnet-20250219": {
-    maxTokens: 64e3,
-    contextWindow: 2e5,
-    supportsImages: true,
-    supportsComputerUse: true,
-    supportsPromptCache: true,
-    inputPrice: 3,
-    outputPrice: 15,
-    cacheWritesPrice: 3.75,
-    cacheReadsPrice: 0.3,
-    reasoning: true
-  },
-  "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);
-    this.#options = options;
-    this.#client = new 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, signal) {
-    let stream;
-    const modelId = this.model.id;
-    const cacheControl = this.#options.enableCache ? { type: "ephemeral" } : void 0;
-    let temperature = 0;
-    let thinkingBudgetTokens = 0;
-    if (this.model.info.reasoning) {
-      thinkingBudgetTokens = this.#options.parameters.thinkingBudgetTokens ?? 0;
-    }
-    if (thinkingBudgetTokens > 0) {
-      temperature = void 0;
-    }
-    switch (modelId) {
-      // 'latest' alias does not support cache_control
-      case "claude-sonnet-4-20250514":
-      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,
-            thinking: thinkingBudgetTokens ? { type: "enabled", budget_tokens: thinkingBudgetTokens } : void 0,
-            temperature,
-            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
-          },
-          { signal }
-        );
-        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,
-            stream: true
-          },
-          { signal }
-        );
-        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;
-            case "thinking":
-              yield {
-                type: "reasoning",
-                text: chunk.content_block.thinking
-              };
-              break;
-            case "redacted_thinking":
-              yield {
-                type: "reasoning",
-                text: "[Redacted by providered]"
-              };
-              break;
-          }
-          break;
-        case "content_block_delta":
-          switch (chunk.delta.type) {
-            case "text_delta":
-              yield {
-                type: "text",
-                text: chunk.delta.text
-              };
-              break;
-            case "thinking_delta":
-              yield {
-                type: "reasoning",
-                text: chunk.delta.thinking
-              };
-              break;
-          }
-          break;
-        case "content_block_stop":
-          break;
-      }
-    }
-  }
-};
-
-// src/AiService/DeepSeekService.ts
-import OpenAI from "openai";
-
-// 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") {
-                if (part.source.type === "base64") {
-                  return {
-                    type: "image_url",
-                    image_url: {
-                      url: `data:${part.source.media_type};base64,${part.source.data}`
-                    }
-                  };
-                }
-                return {
-                  type: "image_url",
-                  image_url: {
-                    url: part.source.url
-                  }
-                };
-              }
-              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
-        });
+// src/UsageMeter.ts
+var UsageMeter = class {
+  #totals = { input: 0, output: 0, cachedRead: 0, cost: 0 };
+  #calls = 0;
+  #modelInfos;
+  #maxMessages;
+  #maxCost;
+  constructor(modelInfos = {}, opts = {}) {
+    const infos = {};
+    for (const [provider, providerInfo] of Object.entries(modelInfos)) {
+      for (const [model, modelInfo] of Object.entries(providerInfo)) {
+        infos[`${provider.split("-")[0]}:${model.replace(/[\.-]/g, "")}`] = {
+          inputPrice: modelInfo.inputPrice ?? 0,
+          outputPrice: modelInfo.outputPrice ?? 0,
+          cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
+          cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0
+        };
       }
     }
+    this.#modelInfos = infos;
+    this.#maxMessages = opts.maxMessages ?? 1e3;
+    this.#maxCost = opts.maxCost ?? 100;
   }
-  return openAiMessages;
-}
-
-// src/AiService/DeepSeekService.ts
-var DeepSeekService = class extends AiServiceBase {
-  #client;
-  model;
-  constructor(options) {
-    super(options);
-    this.#client = new OpenAI({
-      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, signal) {
-    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 }
-      },
-      { signal }
-    );
-    for await (const chunk of stream) {
-      const delta = chunk.choices[0]?.delta;
-      if (delta?.reasoning_content) {
-        yield {
-          type: "reasoning",
-          text: delta.reasoning_content
+  #calculageUsage(usage, providerMetadata, modelInfo) {
+    const providerMetadataKey = Object.keys(providerMetadata ?? {})[0];
+    const metadata = providerMetadata?.[providerMetadataKey] ?? {};
+    switch (providerMetadataKey) {
+      case "openrouter":
+        return {
+          input: usage.inputTokens ?? 0,
+          output: usage.outputTokens ?? 0,
+          cachedRead: usage.cachedInputTokens ?? 0,
+          cost: metadata.usage?.cost ?? 0
         };
-      }
-      if (delta?.content) {
-        yield {
-          type: "text",
-          text: delta.content
+      case "anthropic": {
+        const cachedRead = usage.cachedInputTokens ?? 0;
+        const cacheWrite = metadata?.promptCacheMissTokens ?? 0;
+        const input = usage.inputTokens ?? 0;
+        const output = usage.outputTokens ?? 0;
+        return {
+          input: input + cacheWrite + cachedRead,
+          output,
+          cachedRead,
+          cost: (input * modelInfo.inputPrice + output * modelInfo.outputPrice + cacheWrite * modelInfo.cacheWritesPrice + cachedRead * modelInfo.cacheReadsPrice) / 1e6
         };
       }
-      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
+      case "deepseek": {
+        const cachedRead = usage.cachedInputTokens ?? 0;
+        const cacheWrite = metadata.promptCacheMissTokens ?? 0;
+        const input = usage.inputTokens ?? 0;
+        const output = usage.outputTokens ?? 0;
+        return {
+          input,
+          output,
+          cachedRead,
+          cost: (output * modelInfo.outputPrice + cacheWrite * modelInfo.inputPrice + cachedRead * modelInfo.cacheReadsPrice) / 1e6
         };
       }
-    }
-  }
-};
-
-// src/AiService/OllamaService.ts
-import OpenAI2 from "openai";
-var OllamaService = class extends AiServiceBase {
-  #client;
-  model;
-  constructor(options) {
-    super(options);
-    this.#client = new OpenAI2({
-      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, signal) {
-    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
-      },
-      { signal }
-    );
-    for await (const chunk of stream) {
-      const delta = chunk.choices[0]?.delta;
-      if (delta?.content) {
-        yield {
-          type: "text",
-          text: delta.content
+      default: {
+        const cachedRead = usage.cachedInputTokens ?? 0;
+        const input = usage.inputTokens ?? 0;
+        const output = usage.outputTokens ?? 0;
+        return {
+          input,
+          output,
+          cachedRead,
+          cost: (input * modelInfo.inputPrice + output * modelInfo.outputPrice) / 1e6
         };
       }
     }
   }
-};
-
-// src/AiService/OpenRouterService.ts
-import OpenAI3 from "openai";
-var OpenRouterService = class extends AiServiceBase {
-  #client;
-  #apiKey;
-  #options;
-  #modelProviderInfo;
-  model;
-  constructor(options) {
-    super(options);
-    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 OpenAI3({
-      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: {}
+  addUsage(llm, resp, options = {}) {
+    const modelInfo = options.modelInfo ?? // make google.vertex.chat to google
+    // and anthropic.messages to anthropic
+    this.#modelInfos[`${llm.provider.split(".")[0]}:${llm.modelId.replace(/[\.-]/g, "")}`] ?? {
+      inputPrice: 0,
+      outputPrice: 0,
+      cacheWritesPrice: 0,
+      cacheReadsPrice: 0
     };
-    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, signal) {
-    const openAiMessages = [
-      { role: "system", content: systemPrompt },
-      ...convertToOpenAiMessages(messages)
-    ];
-    const cacheControl = this.#options.enableCache ? { type: "ephemeral" } : void 0;
-    if (this.model.id.startsWith("anthropic/claude")) {
-      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;
-        }
-      }
-    }
-    let reasoning = {};
-    switch (this.model.id) {
-      case "anthropic/claude-3.7-sonnet":
-      case "anthropic/claude-3.7-sonnet:beta":
-      case "anthropic/claude-3.7-sonnet:thinking":
-      case "anthropic/claude-3-7-sonnet":
-      case "anthropic/claude-3-7-sonnet:beta":
-      case "anthropic/claude-opus-4":
-      case "anthropic/claude-sonnet-4": {
-        const budget_tokens = this.#options.parameters.thinkingBudgetTokens || 0;
-        if (budget_tokens > 0) {
-          reasoning = { max_tokens: budget_tokens };
-        }
-        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,
-        messages: openAiMessages,
-        temperature: 0,
-        stream: true,
-        transforms: shouldApplyMiddleOutTransform ? ["middle-out"] : void 0,
-        include_reasoning: true,
-        ...reasoning
-      },
-      { signal }
-    );
-    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
-import { merge } from "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 = 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;
-  }
-  setUsage(usage, messageCount) {
-    this.#usage.inputTokens = usage.inputTokens ?? this.#usage.inputTokens;
-    this.#usage.outputTokens = usage.outputTokens ?? this.#usage.outputTokens;
-    this.#usage.cacheWriteTokens = usage.cacheWriteTokens ?? this.#usage.cacheWriteTokens;
-    this.#usage.cacheReadTokens = usage.cacheReadTokens ?? this.#usage.cacheReadTokens;
-    this.#usage.totalCost = usage.totalCost ?? this.#usage.totalCost;
-    if (messageCount !== void 0) {
-      this.#messageCount = messageCount;
-    }
-  }
-  incrementMessageCount(count = 1) {
-    this.#messageCount += count;
-  }
+    const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
+    const result = this.#calculageUsage(usage, resp.providerMetadata, modelInfo);
+    this.#totals.input += result.input;
+    this.#totals.output += result.output;
+    this.#totals.cachedRead += result.cachedRead;
+    this.#totals.cost += result.cost;
+    this.#calls++;
+  }
+  /** Override the running totals (e.g., restore from saved state). */
+  setUsage(newUsage) {
+    if (newUsage.input != null) this.#totals.input = newUsage.input;
+    if (newUsage.output != null) this.#totals.output = newUsage.output;
+    if (newUsage.cachedRead != null) this.#totals.cachedRead = newUsage.cachedRead;
+    if (newUsage.cost != null) this.#totals.cost = newUsage.cost;
+    if (newUsage.calls != null) this.#calls = newUsage.calls;
+  }
+  /** Manually bump the message count (useful if you record some calls without token info). */
+  incrementMessageCount(n = 1) {
+    this.#calls += n;
+  }
+  /** Return true once either messages or cost exceed the configured caps. */
   isLimitExceeded() {
-    const messageCount = this.#messageCount >= this.maxMessageCount;
-    const cost = this.#usage.totalCost >= this.maxCost;
+    const messageCount = this.#maxMessages !== void 0 && this.#calls >= this.#maxMessages;
+    const cost = this.#maxCost !== void 0 && this.#totals.cost >= this.#maxCost;
     return {
       messageCount,
-      maxMessageCount: this.maxMessageCount,
+      maxMessages: this.#maxMessages,
       cost,
-      maxCost: this.maxCost,
+      maxCost: this.#maxCost,
       result: messageCount || cost
     };
   }
+  /** Same as isLimitExceeded but throws an error if a limit is hit. */
   checkLimit() {
     const result = this.isLimitExceeded();
     if (result.result) {
       throw new Error(
-        `Usage limit exceeded. Message count: ${result.messageCount}/${result.maxMessageCount}, cost: ${result.cost}/${result.maxCost}`
+        `Usage limit exceeded. Message count: ${result.messageCount}/${result.maxMessages}, cost: ${result.cost}/${result.maxCost}`
       );
     }
   }
-  /**
-   * Get current usage totals
-   */
+  /** Getter for the aggregated totals (immutable copy). */
   get usage() {
-    return { ...this.#usage, messageCount: this.#messageCount };
+    return { ...this.#totals, messageCount: this.#calls };
   }
+  /** Print a concise usage summary to console. */
   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}`);
+    const u = this.usage;
+    console.log(
+      `Usage - messages: ${u.messageCount}, input: ${u.input}, cached: ${u.cachedRead}, output: ${u.output}, cost: $${u.cost.toFixed(4)}`
+    );
   }
-};
-
-// 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);
+  onFinishHandler(llm) {
+    return (evt) => {
+      this.addUsage(llm, evt);
+    };
   }
 };
 
@@ -912,10 +189,12 @@ __export(allTools_exports, {
   renameFile: () => renameFile_default,
   replaceInFile: () => replaceInFile_default,
   searchFiles: () => searchFiles_default,
-  updateKnowledge: () => updateKnowledge_default,
   writeToFile: () => writeToFile_default
 });
 
+// src/tools/askFollowupQuestion.ts
+import { z } from "zod";
+
 // src/tool.ts
 var PermissionLevel = /* @__PURE__ */ ((PermissionLevel2) => {
   PermissionLevel2[PermissionLevel2["None"] = 0] = "None";
@@ -936,200 +215,17 @@ var ToolResponseType = /* @__PURE__ */ ((ToolResponseType2) => {
   return ToolResponseType2;
 })(ToolResponseType || {});
 
-// src/tools/utils/getArg.ts
-var getString = (args, name, defaultValue) => {
-  if (typeof args !== "object" || Array.isArray(args)) {
-    throw new Error(`Invalid argument type: ${name} ${args}`);
-  }
-  const ret = args[name] ?? defaultValue;
-  if (ret === void 0) {
-    throw new Error(`Missing required argument: ${name}`);
-  }
-  if (typeof ret !== "string") {
-    throw new Error(`Invalid argument type: ${name} ${ret}`);
-  }
-  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 [];
-  }
-  if (Array.isArray(ret)) {
-    for (const item of ret) {
-      if (typeof item !== "string") {
-        throw new Error(`Invalid argument type: ${name} ${item}`);
-      }
-    }
-    return ret;
-  }
-  if (typeof ret !== "string") {
-    throw new Error(`Invalid argument type: ${name} ${ret}`);
-  }
-  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;
-  }
-  if (typeof ret !== "string") {
-    throw new Error(`Invalid argument type: ${name} ${ret}`);
-  }
-  switch (ret.toLowerCase()) {
-    case "true":
-      return true;
-    case "false":
-      return false;
-    default:
-      throw new Error(`Invalid argument value: ${name} ${ret}`);
-  }
-};
-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;
-  }
-  if (typeof ret !== "string") {
-    throw new Error(`Invalid argument type: ${name} ${ret}`);
-  }
-  const parsed = Number.parseInt(ret);
-  if (Number.isNaN(parsed)) {
-    throw new Error(`Invalid argument value: ${name} ${ret}`);
-  }
-  return parsed;
-};
-var getArray = (args, name, defaultValue) => {
-  if (typeof args !== "object" || Array.isArray(args)) {
-    throw new Error(`Invalid argument type: ${name} ${args}`);
-  }
-  const ret = args[name];
-  if (ret === void 0) {
-    if (defaultValue === void 0) {
-      throw new Error(`Missing required argument: ${name}`);
-    }
-    return defaultValue;
-  }
-  if (Array.isArray(ret)) {
-    return ret;
-  }
-  return [ret];
-};
-
-// src/tools/utils/replaceInFile.ts
-var replaceInFile = (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);
-    }
-    return null;
-  };
-  let updatedFile = fileContent;
-  let appliedCount = 0;
-  const totalCount = blocks.length;
-  for (const { search, replace } of blocks) {
-    const result = findAndReplace(updatedFile, search, replace);
-    if (result !== null) {
-      updatedFile = result;
-      appliedCount++;
-    }
-  }
-  let status;
-  if (appliedCount === 0) {
-    status = "no_diff_applied";
-  } else if (appliedCount < totalCount) {
-    status = "some_diff_applied";
-  } else {
-    status = "all_diff_applied";
-  }
-  return {
-    content: updatedFile,
-    status,
-    appliedCount,
-    totalCount
-  };
-};
-
 // src/tools/askFollowupQuestion.ts
+var questionObject = z.object({
+  prompt: z.string().describe("The text of the question.").meta({ usageValue: "question text here" }),
+  options: z.array(z.string()).default([]).describe("Ordered list of suggested answers (omit if none).").meta({ usageValue: "suggested answer here" })
+});
 var toolInfo = {
   name: "ask_followup_question",
   description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.",
-  parameters: [
-    {
-      name: "questions",
-      description: "One or more follow-up questions you need answered before you can continue.",
-      required: true,
-      allowMultiple: true,
-      usageValue: "questions here",
-      children: [
-        {
-          name: "prompt",
-          description: "The text of the question.",
-          required: true,
-          usageValue: "question text here"
-        },
-        {
-          name: "options",
-          description: "Ordered list of suggested answers (omit if none).",
-          required: false,
-          allowMultiple: true,
-          usageValue: "suggested answer here"
-        }
-      ]
-    }
-  ],
+  parameters: z.object({
+    questions: z.array(questionObject).describe("One or more follow-up questions you need answered before you can continue.").meta({ usageValue: "questions here" })
+  }),
   examples: [
     {
       description: "Single clarifying question (no options)",
@@ -1189,19 +285,18 @@ var handler = async (provider, args) => {
       message: "Not possible to ask followup question. Abort."
     };
   }
-  const questions = getArray(args, "questions");
-  if (!questions || questions.length === 0) {
+  const { questions } = toolInfo.parameters.parse(args);
+  if (questions.length === 0) {
     return {
-      type: "Error" /* Error */,
+      type: "Invalid" /* Invalid */,
       message: "No questions provided"
     };
   }
   const answers = [];
   for (const question of questions) {
-    const prompt6 = getString(question, "prompt");
-    const options = getArray(question, "options", []);
-    const answer = await provider.askFollowupQuestion(prompt6, options);
-    answers.push(`<ask_followup_question_answer question="${prompt6}">
+    const { prompt: prompt5, options } = question;
+    const answer = await provider.askFollowupQuestion(prompt5, options);
+    answers.push(`<ask_followup_question_answer question="${prompt5}">
 ${answer}
 </ask_followup_question_answer>`);
   }
@@ -1220,17 +315,15 @@ var askFollowupQuestion_default = {
 };
 
 // src/tools/attemptCompletion.ts
+import { z as z2 } from "zod";
 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"
-    }
-  ],
+  parameters: z2.object({
+    result: z2.string().describe(
+      "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."
+    ).meta({ usageValue: "Your final result description here" })
+  }),
   examples: [
     {
       description: "Request to present the result of the task",
@@ -1245,7 +338,14 @@ var toolInfo2 = {
   permissionLevel: 0 /* None */
 };
 var handler2 = async (provider, args) => {
-  const result = getString(args, "result");
+  const parsed = toolInfo2.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      type: "Invalid" /* Invalid */,
+      message: `Invalid arguments for attempt_completion: ${parsed.error.message}`
+    };
+  }
+  const { result } = parsed.data;
   const moreMessage = await provider.attemptCompletion?.(result);
   if (!moreMessage) {
     return {
@@ -1268,41 +368,26 @@ var attemptCompletion_default = {
 };
 
 // src/tools/delegate.ts
+import { z as z3 } from "zod";
 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"
-    }
-  ],
+  parameters: z3.object({
+    agentName: z3.string().describe("The name of the agent to delegate the task to").meta({ usageValue: "Name of the target agent" }),
+    task: z3.string().describe("The task to be completed by the target agent").meta({ usageValue: "Task description" }),
+    context: z3.string().describe("The context information for the task").meta({ usageValue: "Context information" }),
+    files: z3.preprocess((val) => {
+      if (!val) return [];
+      const values = Array.isArray(val) ? val : [val];
+      return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+    }, z3.array(z3.string())).optional().describe("The files relevant to the task. Comma separated paths").meta({ usageValue: "Relevant files" })
+  }),
   examples: [
     {
       description: "Delegate a code analysis task to the analyzer agent",
       parameters: [
         {
-          name: "agent_name",
+          name: "agentName",
           value: "analyzer"
         },
         {
@@ -1323,16 +408,20 @@ var toolInfo3 = {
   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", []);
+  const parsed = toolInfo3.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      type: "Invalid" /* Invalid */,
+      message: `Invalid arguments for delegate: ${parsed.error.message}`
+    };
+  }
+  const { agentName, task, context, files } = parsed.data;
   return {
     type: "Delegate" /* Delegate */,
     agentName,
     task,
     context,
-    files
+    files: files ?? []
   };
 };
 var isAvailable3 = (_provider) => {
@@ -1345,29 +434,29 @@ var delegate_default = {
 };
 
 // src/tools/executeCommand.ts
+import { z as z4 } from "zod";
 var toolInfo4 = {
   name: "execute_command",
   description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.",
-  parameters: [
-    {
-      name: "command",
-      description: "The exact command to run  (valid for the current OS). It must be correctly formatted and free of harmful instructions.",
-      required: true,
-      usageValue: "your-command-here"
-    },
-    {
-      name: "requires_approval",
-      description: "Set to `true` for commands that install/uninstall software, modify or delete files, change system settings, perform network operations, or have other side effects. Use `false` for safe, read-only, or purely local development actions (e.g., listing files, make a build, running tests).",
-      required: false,
-      usageValue: "true | false"
-    }
-  ],
+  parameters: z4.object({
+    command: z4.string().describe("The exact command to run  (valid for the current OS). It must be correctly formatted and free of harmful instructions.").meta({ usageValue: "your-command-here" }),
+    requiresApproval: z4.preprocess((val) => {
+      if (typeof val === "string") {
+        const lower = val.toLowerCase();
+        if (lower === "false") return false;
+        if (lower === "true") return true;
+      }
+      return val;
+    }, z4.boolean().optional().default(false)).describe(
+      "Set to `true` for commands that install/uninstall software, modify or delete files, change system settings, perform network operations, or have other side effects. Use `false` for safe, read-only, or purely local development actions (e.g., listing files, make a build, running tests)."
+    ).meta({ usageValue: "true | false" })
+  }),
   examples: [
     {
       description: "Make a build",
       parameters: [
         { name: "command", value: "npm run build" },
-        { name: "requires_approval", value: "false" }
+        { name: "requiresApproval", value: "false" }
       ]
     }
   ],
@@ -1380,10 +469,11 @@ var handler4 = async (provider, args) => {
       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>
+  const { command, requiresApproval } = toolInfo4.parameters.parse(args);
+  try {
+    console.log("Executing command:", command, "Requires approval:", requiresApproval);
+    const result = await provider.executeCommand(command, requiresApproval);
+    const message = `<command>${command}</command>
 <command_exit_code>${result.exitCode}</command_exit_code>
 <command_stdout>
 ${result.stdout}
@@ -1391,16 +481,22 @@ ${result.stdout}
 <command_stderr>
 ${result.stderr}
 </command_stderr>`;
-  if (result.exitCode === 0) {
+    if (result.exitCode === 0) {
+      return {
+        type: "Reply" /* Reply */,
+        message
+      };
+    }
     return {
-      type: "Reply" /* Reply */,
+      type: "Error" /* Error */,
       message
     };
+  } catch (error) {
+    return {
+      type: "Error" /* Error */,
+      message: error instanceof Error ? error.message : String(error)
+    };
   }
-  return {
-    type: "Error" /* Error */,
-    message
-  };
 };
 var isAvailable4 = (provider) => {
   return !!provider.executeCommand;
@@ -1412,16 +508,17 @@ var executeCommand_default = {
 };
 
 // src/tools/fetchUrl.ts
+import { z as z5 } from "zod";
 var toolInfo5 = {
   name: "fetch_url",
   description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.",
-  parameters: [
-    {
-      name: "url",
-      description: "One or more URLs to fetch, separated by commas if multiple.",
-      required: true
-    }
-  ],
+  parameters: z5.object({
+    url: z5.preprocess((val) => {
+      if (!val) return [];
+      const values = Array.isArray(val) ? val : [val];
+      return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+    }, z5.array(z5.string())).describe("One or more URLs to fetch, separated by commas if multiple.").meta({ usageValue: "url" })
+  }),
   examples: [
     {
       description: "Fetch a single webpage",
@@ -1460,7 +557,7 @@ var handler5 = async (provider, args) => {
       message: "Not possible to fetch url. Abort."
     };
   }
-  const urls = getStringArray(args, "url");
+  const { url: urls } = toolInfo5.parameters.parse(args);
   if (urls.length === 0) {
     return {
       type: "Error" /* Error */,
@@ -1491,31 +588,24 @@ var fetchUrl_default = {
   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)"
-    }
-  ],
+
+// src/tools/listFiles.ts
+import { z as z6 } from "zod";
+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: z6.object({
+    path: z6.string().describe("The path of the directory to list contents for (relative to the current working directory)").meta({ usageValue: "Directory path here" }),
+    maxCount: z6.coerce.number().optional().default(2e3).describe("The maximum number of files to list. Default to 2000").meta({ usageValue: "Maximum number of files to list (optional)" }),
+    recursive: z6.preprocess((val) => {
+      if (typeof val === "string") {
+        const lower = val.toLowerCase();
+        if (lower === "false") return false;
+        if (lower === "true") return true;
+      }
+      return val;
+    }, z6.boolean().optional().default(true)).describe("Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.").meta({ usageValue: "true or false (optional)" })
+  }),
   examples: [
     {
       description: "Request to list files",
@@ -1525,7 +615,7 @@ var toolInfo6 = {
           value: "src"
         },
         {
-          name: "max_count",
+          name: "maxCount",
           value: "100"
         }
       ]
@@ -1540,9 +630,7 @@ var handler6 = async (provider, args) => {
       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 { path, maxCount, recursive } = toolInfo6.parameters.parse(args);
   const [files, limitReached] = await provider.listFiles(path, recursive, maxCount);
   return {
     type: "Reply" /* Reply */,
@@ -1563,17 +651,17 @@ var listFiles_default = {
 };
 
 // src/tools/readFile.ts
+import { z as z7 } from "zod";
 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"
-    }
-  ],
+  parameters: z7.object({
+    path: z7.preprocess((val) => {
+      if (!val) return [];
+      const values = Array.isArray(val) ? val : [val];
+      return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+    }, z7.array(z7.string())).describe("The path of the file to read").meta({ usageValue: "Comma separated paths here" })
+  }),
   examples: [
     {
       description: "Request to read the contents of a file",
@@ -1603,7 +691,7 @@ var handler7 = async (provider, args) => {
       message: "Not possible to read file. Abort."
     };
   }
-  const paths = getStringArray(args, "path");
+  const { path: paths } = toolInfo7.parameters.parse(args);
   const resp = [];
   for (const path of paths) {
     const fileContent = await provider.readFile(path);
@@ -1632,20 +720,91 @@ var readFile_default = {
   isAvailable: isAvailable7
 };
 
+// src/tools/replaceInFile.ts
+import { z as z8 } from "zod";
+
+// src/tools/utils/replaceInFile.ts
+var replaceInFile = (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);
+    }
+    return null;
+  };
+  let updatedFile = fileContent;
+  let appliedCount = 0;
+  const totalCount = blocks.length;
+  for (const { search, replace } of blocks) {
+    const result = findAndReplace(updatedFile, search, replace);
+    if (result !== null) {
+      updatedFile = result;
+      appliedCount++;
+    }
+  }
+  let status;
+  if (appliedCount === 0) {
+    status = "no_diff_applied";
+  } else if (appliedCount < totalCount) {
+    status = "some_diff_applied";
+  } else {
+    status = "all_diff_applied";
+  }
+  return {
+    content: updatedFile,
+    status,
+    appliedCount,
+    totalCount
+  };
+};
+
 // 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:
+  parameters: z8.object({
+    path: z8.string().describe("The path of the file to modify").meta({ usageValue: "File path here" }),
+    diff: z8.string().describe(
+      `One or more SEARCH/REPLACE blocks following this exact format:
 \`\`\`
 <<<<<<< SEARCH
 [exact content to find]
@@ -1668,11 +827,9 @@ Critical rules:
     * 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"
-    }
-  ],
+    * To delete code: Use empty REPLACE section`
+    ).meta({ usageValue: "Search and replace blocks here" })
+  }),
   examples: [
     {
       description: "Request to replace sections of content in a file",
@@ -1683,8 +840,7 @@ Critical rules:
         },
         {
           name: "diff",
-          value: `
-<<<<<<< SEARCH
+          value: `<<<<<<< SEARCH
 import React from 'react';
 =======
 import React, { useState } from 'react';
@@ -1710,8 +866,7 @@ function handleSubmit() {
 
 return (
   <div>
->>>>>>> REPLACE
-`
+>>>>>>> REPLACE`
         }
       ]
     },
@@ -1724,13 +879,11 @@ return (
         },
         {
           name: "diff",
-          value: `
-<<<<<<< SEARCH
+          value: `<<<<<<< SEARCH
 const API_URL = 'https://api.example.com';
 =======
 const API_URL = 'https://api.staging.example.com';
->>>>>>> REPLACE
-`
+>>>>>>> REPLACE`
         }
       ]
     },
@@ -1743,8 +896,7 @@ const API_URL = 'https://api.staging.example.com';
         },
         {
           name: "diff",
-          value: `
-<<<<<<< SEARCH
+          value: `<<<<<<< SEARCH
 function helperA() {
   // ...
 }
@@ -1756,8 +908,7 @@ function helperA() {
 function newHelper() {
   // implementation
 }
->>>>>>> REPLACE
-`
+>>>>>>> REPLACE`
         }
       ]
     },
@@ -1770,15 +921,13 @@ function newHelper() {
         },
         {
           name: "diff",
-          value: `
-<<<<<<< SEARCH
+          value: `<<<<<<< SEARCH
 function oldFeature() {
   // This is no longer needed
 }
 
 =======
->>>>>>> REPLACE
-`
+>>>>>>> REPLACE`
         }
       ]
     }
@@ -1792,37 +941,43 @@ var handler8 = async (provider, args) => {
       message: "Not possible to replace in file. Abort."
     };
   }
-  const path = getString(args, "path");
-  const diff = getString(args, "diff");
-  const fileContent = await provider.readFile(path);
-  if (fileContent == null) {
-    return {
-      type: "Error" /* Error */,
-      message: `<replace_in_file_result path="${path}" status="failed" message="File not found" />`
-    };
-  }
-  const result = replaceInFile(fileContent, diff);
-  if (result.status === "no_diff_applied") {
-    return {
-      type: "Error" /* Error */,
-      message: `<replace_in_file_result path="${path}" status="failed" message="Unable to apply changes">
+  try {
+    const { path, diff } = toolInfo8.parameters.parse(args);
+    const fileContent = await provider.readFile(path);
+    if (fileContent == null) {
+      return {
+        type: "Error" /* Error */,
+        message: `<replace_in_file_result path="${path}" status="failed" message="File not found" />`
+      };
+    }
+    const result = replaceInFile(fileContent, diff);
+    if (result.status === "no_diff_applied") {
+      return {
+        type: "Error" /* Error */,
+        message: `<replace_in_file_result path="${path}" status="failed" message="Unable to apply changes">
   <file_content path="${path}">${fileContent}</file_content>
 </replace_in_file_result>`
-    };
-  }
-  await provider.writeFile(path, result.content);
-  if (result.status === "some_diff_applied") {
-    return {
-      type: "Reply" /* Reply */,
-      message: `<replace_in_file_result path="${path}" status="some_diff_applied" applied_count="${result.appliedCount}" total_count="${result.totalCount}">
+      };
+    }
+    await provider.writeFile(path, result.content);
+    if (result.status === "some_diff_applied") {
+      return {
+        type: "Reply" /* Reply */,
+        message: `<replace_in_file_result path="${path}" status="some_diff_applied" applied_count="${result.appliedCount}" total_count="${result.totalCount}">
   <file_content path="${path}">${result.content}</file_content>
 </replace_in_file_result>`
+      };
+    }
+    return {
+      type: "Reply" /* Reply */,
+      message: `<replace_in_file_result path="${path}" status="all_diff_applied" />`
+    };
+  } catch (error) {
+    return {
+      type: "Invalid" /* Invalid */,
+      message: `Invalid arguments for replace_in_file: ${error}`
     };
   }
-  return {
-    type: "Reply" /* Reply */,
-    message: `<replace_in_file_result path="${path}" status="all_diff_applied" />`
-  };
 };
 var isAvailable8 = (provider) => {
   return !!provider.readFile && !!provider.writeFile;
@@ -1834,29 +989,23 @@ var replaceInFile_default = {
 };
 
 // src/tools/searchFiles.ts
+import { z as z9 } from "zod";
 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,
+  parameters: z9.object({
+    path: z9.string().describe(
+      "The path of the directory to search in (relative to the current working directory). This directory will be recursively searched."
+    ).meta({ usageValue: "Directory path here" }),
+    regex: z9.string().describe("The regular expression pattern to search for. Uses Rust regex syntax.").meta({
       usageValue: "Your regex pattern here"
-    },
-    {
-      name: "file_pattern",
-      description: 'Comma-separated glob pattern to filter files (e.g., "*.ts" for TypeScript files or "*.ts,*.js" for both TypeScript and JavaScript files). If not provided, it will search all files (*).',
-      required: false,
+    }),
+    filePattern: z9.string().optional().describe(
+      'Comma-separated glob pattern to filter files (e.g., "*.ts" for TypeScript files or "*.ts,*.js" for both TypeScript and JavaScript files). If not provided, it will search all files (*).'
+    ).meta({
       usageValue: "file pattern here (optional)"
-    }
-  ],
+    })
+  }),
   examples: [
     {
       description: "Request to perform a regex search across files",
@@ -1868,374 +1017,63 @@ var toolInfo9 = {
         {
           name: "regex",
           value: "^components/"
-        },
-        {
-          name: "file_pattern",
-          value: "*.ts,*.tsx"
-        }
-      ]
-    }
-  ],
-  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/updateKnowledge.ts
-import YAML from "yaml";
-
-// src/path.ts
-function dirname(path) {
-  if (path.length === 0) return ".";
-  const isRooted = path[0] === "/";
-  let end = path.length - 1;
-  while (end > 0 && path[end] === "/") end--;
-  const idx = path.lastIndexOf("/", end);
-  if (idx < 0) {
-    return isRooted ? "/" : ".";
-  }
-  if (isRooted && idx === 0) {
-    return "/";
-  }
-  return path.slice(0, idx);
-}
-function normalize(path) {
-  const isAbsolute = path.startsWith("/");
-  const segments = path.split("/").filter(Boolean);
-  const stack = [];
-  for (const seg of segments) {
-    if (seg === ".") continue;
-    if (seg === "..") {
-      if (stack.length && stack[stack.length - 1] !== "..") {
-        stack.pop();
-      } else if (!isAbsolute) {
-        stack.push("..");
-      }
-    } else {
-      stack.push(seg);
-    }
-  }
-  let result = stack.join("/");
-  if (!result && !isAbsolute) return ".";
-  if (result && path.endsWith("/")) result += "/";
-  return (isAbsolute ? "/" : "") + result;
-}
-function join(...parts) {
-  if (parts.length === 0) return ".";
-  let combined = "";
-  for (const p of parts) {
-    if (typeof p !== "string") {
-      throw new TypeError("Arguments to join must be strings");
-    }
-    if (p) {
-      combined = combined ? `${combined}/${p}` : p;
-    }
-  }
-  return normalize(combined);
-}
-
-// src/tools/updateKnowledge.ts
-var toolInfo10 = {
-  name: "update_knowledge",
-  description: "Update knowledge in a knowledge.ai.yml file with smart merging capabilities. This tool lets you add, update, or remove information using path-based updates and special directives.",
-  parameters: [
-    {
-      name: "path",
-      description: "Directory containing (or where to create) the knowledge.ai.yml file",
-      required: true,
-      usageValue: "Directory path here"
-    },
-    {
-      name: "knowledge",
-      description: "YAML content to merge into the knowledge file",
-      required: true,
-      usageValue: "YAML content with knowledge to update"
-    }
-  ],
-  examples: [
-    {
-      description: "Add a new file entry",
-      parameters: [
-        { name: "path", value: "src/utils" },
-        {
-          name: "knowledge",
-          value: `files:
-  "newFile.ts":
-    description: "A new utility file"
-    api:
-      functions:
-        1:
-          name: "processData"
-          params:
-            1: { name: "data", type: "object" }
-          returns: "object"`
-        }
-      ]
-    },
-    {
-      description: "Update an existing file description",
-      parameters: [
-        { name: "path", value: "src/utils" },
-        {
-          name: "knowledge",
-          value: `files:
-  "existingFile.ts":
-    description: "Updated description for the file"`
-        }
-      ]
-    },
-    {
-      description: "Add a new rule",
-      parameters: [
-        { name: "path", value: "src" },
-        {
-          name: "knowledge",
-          value: `rules:
-    10: "New rule to follow"`
-        }
-      ]
-    },
-    {
-      description: "Remove a rule",
-      parameters: [
-        { name: "path", value: "src" },
-        {
-          name: "knowledge",
-          value: `rules:
-    5: null`
-        }
-      ]
-    },
-    {
-      description: "Update nested properties using dot notation",
-      parameters: [
-        { name: "path", value: "src/components" },
-        {
-          name: "knowledge",
-          value: `files.Button.tsx.api.functions.1.description: "Updated function description"`
-        }
-      ]
-    }
-  ],
-  permissionLevel: 2 /* Write */
-};
-function getNextKey(obj) {
-  if (!obj || typeof obj !== "object") return 1;
-  const numericKeys = Object.keys(obj).filter((key) => !Number.isNaN(Number(key))).map((key) => Number(key));
-  if (numericKeys.length === 0) return 1;
-  return Math.max(...numericKeys) + 1;
-}
-function arrayToNumberedDict(arr) {
-  const result = {};
-  arr.forEach((item, index) => {
-    result[(index + 1).toString()] = item;
-  });
-  return result;
-}
-function deepMerge(target, source) {
-  if (source && typeof source === "object") {
-    if (Array.isArray(target)) {
-      target = arrayToNumberedDict(target);
-    }
-    if (Array.isArray(source)) {
-      source = arrayToNumberedDict(source);
-    }
-    if (typeof target === "object" && !Array.isArray(target) && "$merge" in source) {
-      const result = { ...target };
-      const itemsToMerge = Array.isArray(source.$merge) ? source.$merge : [source.$merge];
-      for (const item of itemsToMerge) {
-        if (typeof item === "object" && item !== null && "path" in item) {
-          let found = false;
-          for (const key in result) {
-            if (typeof result[key] === "object" && result[key] !== null && "path" in result[key] && result[key].path === item.path) {
-              result[key] = deepMerge(result[key], item);
-              found = true;
-              break;
-            }
-          }
-          if (!found) {
-            const nextKey = getNextKey(result).toString();
-            result[nextKey] = item;
-          }
-        } else {
-          const nextKey = getNextKey(result).toString();
-          result[nextKey] = item;
-        }
-      }
-      return result;
-    }
-    if (typeof target === "object" && !Array.isArray(target) && "$remove" in source) {
-      const result = { ...target };
-      const itemsToRemove = Array.isArray(source.$remove) ? source.$remove : [source.$remove];
-      for (const item of itemsToRemove) {
-        if (typeof item === "string" && !Number.isNaN(Number(item))) {
-          delete result[item];
-        } else if (typeof item === "object" && item !== null && "path" in item) {
-          for (const key in result) {
-            if (typeof result[key] === "object" && result[key] !== null && "path" in result[key] && result[key].path === item.path) {
-              delete result[key];
-              break;
-            }
-          }
-        } else {
-          for (const key in result) {
-            if (result[key] === item) {
-              delete result[key];
-              break;
-            }
-          }
-        }
-      }
-      return result;
-    }
-    if (typeof target === "object" && !Array.isArray(target) && "$replace" in source) {
-      const replacements = Array.isArray(source.$replace) ? source.$replace : [source.$replace];
-      return arrayToNumberedDict(replacements);
-    }
-  }
-  if (!source || typeof source !== "object") {
-    return source;
-  }
-  if (!target || typeof target !== "object") {
-    if (Array.isArray(source)) {
-      return arrayToNumberedDict(source);
+        },
+        {
+          name: "filePattern",
+          value: "*.ts,*.tsx"
+        }
+      ]
     }
-    return { ...source };
-  }
-  const output = { ...target };
-  for (const key in source) {
-    if (key.startsWith("$")) continue;
-    output[key] = deepMerge(target[key], source[key]);
-  }
-  return output;
-}
-var handler10 = async (provider, args) => {
-  if (!provider.readFile || !provider.writeFile) {
+  ],
+  permissionLevel: 1 /* Read */
+};
+var handler9 = async (provider, args) => {
+  if (!provider.searchFiles) {
     return {
       type: "Error" /* Error */,
-      message: "File operations not available. Cannot update knowledge file."
+      message: "Not possible to search files. Abort."
     };
   }
-  const dirPath = getString(args, "path");
-  const knowledgeContent = getString(args, "knowledge");
-  const filePath = join(dirPath, "knowledge.ai.yml");
   try {
-    let newKnowledge;
-    try {
-      newKnowledge = YAML.parse(knowledgeContent);
-    } catch (error) {
-      return {
-        type: "Error" /* Error */,
-        message: `Invalid YAML content: ${error.message}`
-      };
-    }
-    const dotNotationUpdates = {};
-    const regularUpdates = {};
-    for (const key in newKnowledge) {
-      if (key.includes(".")) {
-        dotNotationUpdates[key] = newKnowledge[key];
-      } else {
-        regularUpdates[key] = newKnowledge[key];
-      }
-    }
-    const existingContent = await provider.readFile(filePath);
-    let existingKnowledge = {};
-    if (existingContent) {
-      try {
-        existingKnowledge = YAML.parse(existingContent);
-      } catch (error) {
-        return {
-          type: "Error" /* Error */,
-          message: `Error parsing existing knowledge file: ${error.message}`
-        };
-      }
-    }
-    let updatedKnowledge = existingKnowledge;
-    updatedKnowledge = deepMerge(updatedKnowledge, regularUpdates);
-    if (Object.keys(dotNotationUpdates).length > 0) {
-      const nestedUpdates = {};
-      for (const path in dotNotationUpdates) {
-        const parts = path.split(".");
-        let current = nestedUpdates;
-        for (let i = 0; i < parts.length - 1; i++) {
-          const part = parts[i];
-          if (!(part in current)) {
-            current[part] = {};
-          }
-          current = current[part];
-        }
-        current[parts[parts.length - 1]] = dotNotationUpdates[path];
-      }
-      updatedKnowledge = deepMerge(updatedKnowledge, nestedUpdates);
-    }
-    const updatedContent = YAML.stringify(updatedKnowledge);
-    await provider.writeFile(filePath, updatedContent);
+    const { path, regex, filePattern } = toolInfo9.parameters.parse(args);
+    const files = await provider.searchFiles(path, regex, filePattern ?? "*");
     return {
       type: "Reply" /* Reply */,
-      message: `<update_knowledge_path>${filePath}</update_knowledge_path><status>Success</status>`
+      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>
+`
     };
   } catch (error) {
     return {
-      type: "Error" /* Error */,
-      message: `Error updating knowledge file: ${error.message}`
+      type: "Invalid" /* Invalid */,
+      message: `Invalid arguments for search_files: ${error}`
     };
   }
 };
-var isAvailable10 = (provider) => {
-  return !!provider.readFile && !!provider.writeFile;
+var isAvailable9 = (provider) => {
+  return !!provider.searchFiles;
 };
-var updateKnowledge_default = {
-  ...toolInfo10,
-  handler: handler10,
-  isAvailable: isAvailable10
+var searchFiles_default = {
+  ...toolInfo9,
+  handler: handler9,
+  isAvailable: isAvailable9
 };
 
 // src/tools/writeToFile.ts
-var toolInfo11 = {
+import { z as z10 } from "zod";
+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. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.",
-  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"
-    }
-  ],
+  parameters: z10.object({
+    path: z10.string().describe("The path of the file to write to").meta({ usageValue: "File path here" }),
+    content: z10.string().describe(
+      "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."
+    ).meta({ usageValue: "Your file content here" })
+  }),
   examples: [
     {
       description: "Request to write content to a file",
@@ -2264,15 +1102,21 @@ export default App;
   ],
   permissionLevel: 2 /* Write */
 };
-var handler11 = async (provider, args) => {
+var handler10 = async (provider, args) => {
   if (!provider.writeFile) {
     return {
       type: "Error" /* Error */,
       message: "Not possible to write file. Abort."
     };
   }
-  const path = getString(args, "path");
-  let content = getString(args, "content");
+  const parsed = toolInfo10.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      type: "Invalid" /* Invalid */,
+      message: `Invalid arguments for write_to_file: ${parsed.error.message}`
+    };
+  }
+  let { path, content } = parsed.data;
   const trimmedContent = content.trim();
   if (trimmedContent.startsWith("<![CDATA[") && content.endsWith("]]>")) content = trimmedContent.slice(9, -3);
   await provider.writeFile(path, content);
@@ -2281,51 +1125,36 @@ var handler11 = async (provider, args) => {
     message: `<write_to_file_path>${path}</write_to_file_path><status>Success</status>`
   };
 };
-var isAvailable11 = (provider) => {
+var isAvailable10 = (provider) => {
   return !!provider.writeFile;
 };
 var writeToFile_default = {
-  ...toolInfo11,
-  handler: handler11,
-  isAvailable: isAvailable11
+  ...toolInfo10,
+  handler: handler10,
+  isAvailable: isAvailable10
 };
 
 // src/tools/handOver.ts
-var toolInfo12 = {
+import { z as z11 } from "zod";
+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"
-    }
-  ],
+  parameters: z11.object({
+    agentName: z11.string().describe("The name of the agent to hand over the task to").meta({ usageValue: "Name of the target agent" }),
+    task: z11.string().describe("The task to be completed by the target agent").meta({ usageValue: "Task description" }),
+    context: z11.string().describe("The context information for the task").meta({ usageValue: "Context information" }),
+    files: z11.preprocess((val) => {
+      if (!val) return [];
+      const values = Array.isArray(val) ? val : [val];
+      return values.flatMap((i) => typeof i === "string" ? i.split(",") : []).filter((s) => s.length > 0);
+    }, z11.array(z11.string())).optional().describe("The files relevant to the task. Comma separated paths").meta({ usageValue: "Relevant files" })
+  }),
   examples: [
     {
       description: "Hand over a coding task to the coder agent",
       parameters: [
         {
-          name: "agent_name",
+          name: "agentName",
           value: "coder"
         },
         {
@@ -2345,40 +1174,40 @@ var toolInfo12 = {
   ],
   permissionLevel: 0 /* None */
 };
-var handler12 = 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", []);
+var handler11 = async (_provider, args) => {
+  const parsed = toolInfo11.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      type: "Invalid" /* Invalid */,
+      message: `Invalid arguments for hand_over: ${parsed.error.message}`
+    };
+  }
+  const { agentName, task, context, files } = parsed.data;
   return {
     type: "HandOver" /* HandOver */,
     agentName,
     task,
     context,
-    files
+    files: files ?? []
   };
 };
-var isAvailable12 = (_provider) => {
+var isAvailable11 = (_provider) => {
   return true;
 };
 var handOver_default = {
-  ...toolInfo12,
-  handler: handler12,
-  isAvailable: isAvailable12
+  ...toolInfo11,
+  handler: handler11,
+  isAvailable: isAvailable11
 };
 
 // src/tools/removeFile.ts
-var toolInfo13 = {
+import { z as z12 } from "zod";
+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"
-    }
-  ],
+  parameters: z12.object({
+    path: z12.string().describe("The path of the file to remove").meta({ usageValue: "File path here" })
+  }),
   examples: [
     {
       description: "Request to remove a file",
@@ -2392,47 +1221,45 @@ var toolInfo13 = {
   ],
   permissionLevel: 2 /* Write */
 };
-var handler13 = async (provider, args) => {
+var handler12 = async (provider, args) => {
   if (!provider.removeFile) {
     return {
       type: "Error" /* Error */,
       message: "Not possible to remove file. Abort."
     };
   }
-  const path = getString(args, "path");
+  const parsed = toolInfo12.parameters.safeParse(args);
+  if (!parsed.success) {
+    return {
+      type: "Invalid" /* Invalid */,
+      message: `Invalid arguments for remove_file: ${parsed.error.message}`
+    };
+  }
+  const { path } = parsed.data;
   await provider.removeFile(path);
   return {
     type: "Reply" /* Reply */,
     message: `<remove_file_path>${path}</remove_file_path><status>Success</status>`
   };
 };
-var isAvailable13 = (provider) => {
+var isAvailable12 = (provider) => {
   return !!provider.removeFile;
 };
 var removeFile_default = {
-  ...toolInfo13,
-  handler: handler13,
-  isAvailable: isAvailable13
+  ...toolInfo12,
+  handler: handler12,
+  isAvailable: isAvailable12
 };
 
 // src/tools/renameFile.ts
-var toolInfo14 = {
+import { z as z13 } from "zod";
+var toolInfo13 = {
   name: "rename_file",
   description: "Request to rename a file from source path to target path.",
-  parameters: [
-    {
-      name: "source_path",
-      description: "The current path of the file",
-      required: true,
-      usageValue: "Source file path here"
-    },
-    {
-      name: "target_path",
-      description: "The new path for the file",
-      required: true,
-      usageValue: "Target file path here"
-    }
-  ],
+  parameters: z13.object({
+    source_path: z13.string().describe("The current path of the file").meta({ usageValue: "Source file path here" }),
+    target_path: z13.string().describe("The new path for the file").meta({ usageValue: "Target file path here" })
+  }),
   examples: [
     {
       description: "Request to rename a file",
@@ -2450,28 +1277,27 @@ var toolInfo14 = {
   ],
   permissionLevel: 2 /* Write */
 };
-var handler14 = async (provider, args) => {
+var handler13 = async (provider, args) => {
   if (!provider.renameFile) {
     return {
       type: "Error" /* Error */,
       message: "Not possible to rename file. Abort."
     };
   }
-  const sourcePath = getString(args, "source_path");
-  const targetPath = getString(args, "target_path");
-  await provider.renameFile(sourcePath, targetPath);
+  const { source_path, target_path } = toolInfo13.parameters.parse(args);
+  await provider.renameFile(source_path, target_path);
   return {
     type: "Reply" /* Reply */,
-    message: `<rename_file_path>${targetPath}</rename_file_path><status>Success</status>`
+    message: `<rename_file_path>${target_path}</rename_file_path><status>Success</status>`
   };
 };
-var isAvailable14 = (provider) => {
+var isAvailable13 = (provider) => {
   return !!provider.renameFile;
 };
 var renameFile_default = {
-  ...toolInfo14,
-  handler: handler14,
-  isAvailable: isAvailable14
+  ...toolInfo13,
+  handler: handler13,
+  isAvailable: isAvailable13
 };
 
 // src/getAvailableTools.ts
@@ -2499,6 +1325,49 @@ var getAvailableTools = ({
   return tools;
 };
 
+// src/tool-v1-compat.ts
+import { z as z14 } from "zod";
+function zodSchemaToParameters(schema) {
+  const parameters = [];
+  const { shape } = schema;
+  for (const name in shape) {
+    const def = shape[name];
+    const isOptional = def.safeParse(void 0).success;
+    const description = def.description || "";
+    const param = {
+      name,
+      description,
+      required: !isOptional
+    };
+    const usageValue = def.meta()?.usageValue;
+    if (usageValue) {
+      param.usageValue = usageValue;
+    }
+    if (def instanceof z14.ZodObject) {
+      param.children = zodSchemaToParameters(def);
+    } else if (def instanceof z14.ZodArray) {
+      param.allowMultiple = true;
+      const element = def.element;
+      if (element instanceof z14.ZodObject) {
+        param.children = zodSchemaToParameters(element);
+      }
+    }
+    parameters.push(param);
+  }
+  return parameters;
+}
+function toToolInfoV1(tool) {
+  const { parameters: zodSchema, ...rest } = tool;
+  const v1Parameters = zodSchemaToParameters(zodSchema);
+  return {
+    ...rest,
+    parameters: v1Parameters
+  };
+}
+
+// src/Agent/AgentBase.ts
+import { streamText } from "ai";
+
 // src/Agent/parseAssistantMessage.ts
 function parseNestedParameters(content, parameterPrefix, childrenParams) {
   const result = {};
@@ -2885,9 +1754,10 @@ var AgentBase = class {
   ai;
   config;
   handlers;
-  #messages = [];
   #policies;
+  #messages = [];
   #aborted = false;
+  #abortController;
   constructor(name, ai, config) {
     this.ai = ai;
     if (config.agents && config.agents.length > 0) {
@@ -2901,7 +1771,7 @@ ${agents}`;
     }
     const policies = [];
     for (const policy of config.policies) {
-      const instance = policy(handlers);
+      const instance = policy(handlers, config.parameters);
       if (instance) {
         policies.push(instance);
         if (instance.prompt) {
@@ -2918,13 +1788,19 @@ ${instance.prompt}`;
     this.handlers = handlers;
     this.config = config;
     this.#policies = policies;
+    this.#messages.push({
+      role: "system",
+      content: this.config.systemPrompt
+    });
   }
   abort() {
     this.#aborted = true;
-    this.ai.abort();
+    if (this.#abortController) {
+      this.#abortController.abort();
+    }
   }
   get parameters() {
-    return this.ai.options.parameters;
+    return this.config.parameters;
   }
   get messages() {
     return this.#messages;
@@ -2935,15 +1811,15 @@ ${instance.prompt}`;
   async #callback(event) {
     await this.config.callback?.(event);
   }
-  async start(prompt6) {
+  async start(prompt5) {
     this.#callback({ kind: "StartTask" /* StartTask */, agent: this, systemPrompt: this.config.systemPrompt });
-    return await this.#processLoop(prompt6);
+    return await this.#processLoop(prompt5);
   }
-  async step(prompt6) {
+  async step(prompt5) {
     if (this.#messages.length === 0) {
       this.#callback({ kind: "StartTask" /* StartTask */, agent: this, systemPrompt: this.config.systemPrompt });
     }
-    return await this.#request(prompt6);
+    return await this.#request(prompt5);
   }
   async handleStepResponse(response) {
     return this.#handleResponse(response);
@@ -2954,7 +1830,7 @@ ${instance.prompt}`;
       if (this.#aborted) {
         return { type: "Aborted" };
       }
-      if (this.ai.usageMeter.isLimitExceeded().result) {
+      if (this.config.usageMeter.isLimitExceeded().result) {
         this.#callback({ kind: "UsageExceeded" /* UsageExceeded */, agent: this });
         return { type: "UsageExceeded" };
       }
@@ -2987,6 +1863,12 @@ ${instance.prompt}`;
         await instance.onBeforeRequest(this);
       }
     }
+    let messages = this.#messages;
+    for (const instance of this.#policies) {
+      if (instance.prepareMessages) {
+        messages = await instance.prepareMessages(this, messages);
+      }
+    }
     let currentAssistantMessage = "";
     const retryCount = this.config.retryCount ?? 5;
     const requestTimeoutSeconds = this.config.requestTimeoutSeconds ?? 10;
@@ -3000,28 +1882,54 @@ ${instance.prompt}`;
         if (requestTimeoutSeconds > 0) {
           timeout = setTimeout(() => {
             console.debug(`No data received for ${requestTimeoutSeconds} seconds. Aborting request.`);
-            this.ai.abort();
+            this.abort();
           }, requestTimeoutSeconds * 1e3);
         }
       };
-      const stream = this.ai.send(this.config.systemPrompt, this.#messages);
-      try {
-        resetTimeout();
-        for await (const chunk of stream) {
-          resetTimeout();
-          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;
+      this.#abortController = new AbortController();
+      const providerOptions = {};
+      const thinkingBudgetTokens = this.config.parameters?.thinkingBudgetTokens;
+      const enableThinking = thinkingBudgetTokens > 0;
+      if (enableThinking) {
+        providerOptions.anthropic = {
+          thinking: { type: "enabled", budgetTokens: thinkingBudgetTokens }
+        };
+        providerOptions.openrouter = {
+          reasoning: {
+            max_tokens: thinkingBudgetTokens
           }
-        }
+        };
+        providerOptions.google = {
+          thinkingConfig: {
+            includeThoughts: true,
+            thinkingBudget: thinkingBudgetTokens
+          }
+        };
+      }
+      try {
+        const stream = streamText({
+          model: this.ai,
+          messages,
+          providerOptions,
+          onChunk: async ({ chunk }) => {
+            resetTimeout();
+            switch (chunk.type) {
+              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;
+            }
+          },
+          onFinish: this.config.usageMeter.onFinishHandler(this.ai),
+          onError: async (error) => {
+            console.error("Error in stream:", error);
+          },
+          abortSignal: this.#abortController.signal
+        });
+        await stream.consumeStream();
       } catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
           break;
@@ -3046,24 +1954,19 @@ ${instance.prompt}`;
       }
       throw new Error("No assistant message received");
     }
+    console.log("Assistant message:", currentAssistantMessage);
     this.#messages.push({
       role: "assistant",
       content: currentAssistantMessage
     });
-    const ret = parseAssistantMessage(currentAssistantMessage, this.config.tools, this.config.toolNamePrefix);
+    const ret = parseAssistantMessage(currentAssistantMessage, this.config.tools.map(toToolInfoV1), this.config.toolNamePrefix);
     await this.#callback({ kind: "EndRequest" /* EndRequest */, agent: this, message: currentAssistantMessage });
     return ret;
   }
   async #handleResponse(response) {
     const toolResponses = [];
     let hasPause = false;
-    let updatedResponse = response;
-    for (const hook of this.#policies) {
-      if (hook.updateResponse) {
-        updatedResponse = await hook.updateResponse(updatedResponse);
-      }
-    }
-    outer: for (const content of updatedResponse) {
+    outer: for (const content of response) {
       switch (content.type) {
         case "text":
           break;
@@ -3145,8 +2048,8 @@ ${instance.prompt}`;
   }
   async #invokeTool(name, args) {
     try {
-      const handler15 = this.handlers[name]?.handler;
-      if (!handler15) {
+      const handler14 = this.handlers[name]?.handler;
+      if (!handler14) {
         return {
           type: "Error" /* Error */,
           message: responsePrompts.errorInvokeTool(name, "Tool not found"),
@@ -3165,7 +2068,7 @@ ${instance.prompt}`;
       if (resp) {
         return resp;
       }
-      return await handler15(this.config.provider, args);
+      return await handler14(this.config.provider, args);
     } catch (error) {
       return {
         type: "Error" /* Error */,
@@ -3175,15 +2078,15 @@ ${instance.prompt}`;
     }
   }
   get model() {
-    return this.ai.model;
+    return `${this.ai.provider}:${this.ai.modelId}`;
   }
   get usage() {
-    return this.ai.usageMeter.usage;
+    return this.config.usageMeter.usage;
   }
 };
 
 // src/Agent/AnalyzerAgent/prompts.ts
-var fullSystemPrompt = (info, tools, toolNamePrefix, instructions, scripts) => `
+var fullSystemPrompt = (info, tools, toolNamePrefix, instructions, scripts, useNativeTool) => `
 # Analyzer Agent
 
 ## Role
@@ -3204,7 +2107,7 @@ You are the **Analyzer** agent, responsible for:
 5. **Documentation Assessment**: Review documentation quality and completeness.
 6. **Non-Modification**: Never modify code or files - focus solely on analysis.
 
-${toolUsePrompt(tools, toolNamePrefix)}
+${useNativeTool ? "" : toolUsePrompt(tools, toolNamePrefix)}
 ${capabilities(toolNamePrefix)}
 ${systemInformation(info)}
 ${customInstructions(instructions)}
@@ -3227,10 +2130,11 @@ var AnalyzerAgent = class extends AgentBase {
       {
         os: options.os
       },
-      tools,
+      tools.map(toToolInfoV1),
       toolNamePrefix,
       options.customInstructions ?? [],
-      options.scripts ?? {}
+      options.scripts ?? {},
+      options.toolFormat === "native"
     );
     super(analyzerAgentInfo.name, options.ai, {
       systemPrompt,
@@ -3241,7 +2145,10 @@ var AnalyzerAgent = class extends AgentBase {
       agents: options.agents,
       scripts: options.scripts,
       callback: options.callback,
-      policies: options.policies
+      policies: options.policies,
+      toolFormat: options.toolFormat,
+      parameters: options.parameters ?? {},
+      usageMeter: options.usageMeter ?? new UsageMeter()
     });
   }
   onBeforeInvokeTool() {
@@ -3260,7 +2167,7 @@ var analyzerAgentInfo = {
 };
 
 // src/Agent/ArchitectAgent/prompts.ts
-var fullSystemPrompt2 = (info, tools, toolNamePrefix, instructions, scripts) => `
+var fullSystemPrompt2 = (info, tools, toolNamePrefix, instructions, scripts, useNativeTool) => `
 # Architect Agent
 
 ## Role
@@ -3296,7 +2203,7 @@ You are the **Architect** agent, responsible for:
    - If multiple steps are required, break them into numbered tasks to delegate to the **Coder** agent.
    - Provide all necessary context, implementation plan, file references, and clarifications for successful execution.
 
-${toolUsePrompt(tools, toolNamePrefix)}
+${useNativeTool ? "" : toolUsePrompt(tools, toolNamePrefix)}
 ${capabilities(toolNamePrefix)}
 ${systemInformation(info)}
 ${customInstructions(instructions)}
@@ -3319,10 +2226,11 @@ var ArchitectAgent = class extends AgentBase {
       {
         os: options.os
       },
-      tools,
+      tools.map(toToolInfoV1),
       toolNamePrefix,
       options.customInstructions ?? [],
-      options.scripts ?? {}
+      options.scripts ?? {},
+      options.toolFormat === "native"
     );
     super(architectAgentInfo.name, options.ai, {
       systemPrompt,
@@ -3333,7 +2241,10 @@ var ArchitectAgent = class extends AgentBase {
       agents: options.agents,
       scripts: options.scripts,
       callback: options.callback,
-      policies: options.policies
+      policies: options.policies,
+      toolFormat: options.toolFormat,
+      parameters: options.parameters ?? {},
+      usageMeter: options.usageMeter ?? new UsageMeter()
     });
   }
   onBeforeInvokeTool() {
@@ -3416,9 +2327,9 @@ RETRY GUIDELINES
    - Explain why the issue remains
    - Suggest manual intervention steps
    - Report any partial improvements`;
-var fullSystemPrompt3 = (info, tools, toolNamePrefix, instructions, scripts, interactive) => `
+var fullSystemPrompt3 = (info, tools, toolNamePrefix, instructions, scripts, interactive, useNativeTool) => `
 ${basePrompt}
-${toolUsePrompt(tools, toolNamePrefix)}
+${useNativeTool ? "" : toolUsePrompt(tools, toolNamePrefix)}
 ${codeFixingStrategies}
 ${retryGuidelines}
 ${capabilities(toolNamePrefix)}
@@ -3444,11 +2355,12 @@ var CodeFixerAgent = class extends AgentBase {
       {
         os: options.os
       },
-      tools,
+      tools.map(toToolInfoV1),
       toolNamePrefix,
       options.customInstructions ?? [],
       options.scripts ?? {},
-      options.interactive
+      options.interactive,
+      options.toolFormat === "native"
     );
     super(codeFixerAgentInfo.name, options.ai, {
       systemPrompt,
@@ -3459,7 +2371,10 @@ var CodeFixerAgent = class extends AgentBase {
       agents: options.agents,
       scripts: options.scripts,
       callback: options.callback,
-      policies: options.policies
+      policies: options.policies,
+      toolFormat: options.toolFormat,
+      parameters: options.parameters ?? {},
+      usageMeter: options.usageMeter ?? new UsageMeter()
     });
     this.#maxRetries = options.maxRetries ?? 5;
   }
@@ -3618,9 +2533,9 @@ You solve the user's task by working in small, verifiable steps.
 4. **Iterate** - Repeat Plan \u2192 Think \u2192 Act until all goals are complete.
 5. **Complete** - Use ${toolNamePrefix}attempt_completion to deliver the final result. Do not invite further discussion unless the user explicitly requests changes.
 `;
-var fullSystemPrompt4 = (info, tools, toolNamePrefix, instructions, scripts) => `
+var fullSystemPrompt4 = (info, tools, toolNamePrefix, instructions, scripts, useNativeTool) => `
 ${basePrompt2}
-${toolUsePrompt(tools, toolNamePrefix)}
+${useNativeTool ? "" : toolUsePrompt(tools, toolNamePrefix)}
 ${editingFilesPrompt(toolNamePrefix)}
 ${capabilities(toolNamePrefix)}
 ${rules(toolNamePrefix)}
@@ -3646,10 +2561,11 @@ var CoderAgent = class extends AgentBase {
       {
         os: options.os
       },
-      tools,
+      tools.map(toToolInfoV1),
       toolNamePrefix,
       options.customInstructions ?? [],
-      options.scripts ?? {}
+      options.scripts ?? {},
+      options.toolFormat === "native"
     );
     super(coderAgentInfo.name, options.ai, {
       systemPrompt,
@@ -3660,7 +2576,10 @@ var CoderAgent = class extends AgentBase {
       agents: options.agents,
       scripts: options.scripts,
       callback: options.callback,
-      policies: options.policies
+      policies: options.policies,
+      toolFormat: options.toolFormat,
+      parameters: options.parameters ?? {},
+      usageMeter: options.usageMeter ?? new UsageMeter()
     });
   }
   async onBeforeInvokeTool(name, args) {
@@ -3734,24 +2653,24 @@ var MultiAgent = class {
     switch (exitReason.type) {
       case "HandOver" /* HandOver */: {
         this.#agents.pop();
-        const prompt6 = await this.#config.getPrompt?.(
+        const prompt5 = await this.#config.getPrompt?.(
           exitReason.agentName,
           exitReason.task,
           exitReason.context,
           exitReason.files,
           this.#originalTask
         ) ?? exitReason.task;
-        return await this.#startTask(exitReason.agentName, prompt6);
+        return await this.#startTask(exitReason.agentName, prompt5);
       }
       case "Delegate" /* Delegate */: {
-        const prompt6 = await this.#config.getPrompt?.(
+        const prompt5 = await this.#config.getPrompt?.(
           exitReason.agentName,
           exitReason.task,
           exitReason.context,
           exitReason.files,
           this.#originalTask
         ) ?? exitReason.task;
-        const delegateResult = await this.#startTask(exitReason.agentName, prompt6);
+        const delegateResult = await this.#startTask(exitReason.agentName, prompt5);
         switch (delegateResult.type) {
           case "HandOver" /* HandOver */:
           case "Delegate" /* Delegate */:
@@ -3806,214 +2725,79 @@ var MultiAgent = class {
 };
 
 // src/config.ts
-import { z } from "zod";
-var providerModelSchema = z.object({
-  provider: z.string().optional(),
-  model: z.string().optional(),
-  parameters: z.record(z.string(), z.any()).optional()
+import { z as z15 } from "zod";
+var toolFormatSchema = z15.enum(["native", "polka-codes"]).optional();
+var providerModelSchema = z15.object({
+  provider: z15.string().optional(),
+  model: z15.string().optional(),
+  parameters: z15.record(z15.string(), z15.any()).optional(),
+  toolFormat: toolFormatSchema
 });
 var agentSchema = providerModelSchema.extend({
-  initialContext: z.object({
-    maxFileCount: z.number().int().positive().optional(),
-    excludes: z.array(z.string()).optional()
+  initialContext: z15.object({
+    maxFileCount: z15.number().int().positive().optional(),
+    excludes: z15.array(z15.string()).optional()
   }).optional(),
-  retryCount: z.number().int().min(0).optional(),
-  requestTimeoutSeconds: z.number().int().positive().optional()
+  retryCount: z15.number().int().min(0).optional(),
+  requestTimeoutSeconds: z15.number().int().positive().optional()
 });
-var configSchema = z.object({
-  agent: z.string().optional(),
-  prices: z.record(
-    z.string(),
+var configSchema = z15.object({
+  agent: z15.string().optional(),
+  prices: z15.record(
+    z15.string(),
     // provider
-    z.record(
-      z.string(),
+    z15.record(
+      z15.string(),
       // model
-      z.object({
-        inputPrice: z.number().optional(),
-        outputPrice: z.number().optional(),
-        cacheWritesPrice: z.number().optional(),
-        cacheReadsPrice: z.number().optional()
+      z15.object({
+        inputPrice: z15.number().optional(),
+        outputPrice: z15.number().optional(),
+        cacheWritesPrice: z15.number().optional(),
+        cacheReadsPrice: z15.number().optional()
       })
     )
   ).optional(),
-  providers: z.record(
-    z.string(),
-    z.object({
-      apiKey: z.string().optional(),
-      defaultModel: z.string().optional(),
-      defaultParameters: z.record(z.string(), z.any()).optional()
+  providers: z15.record(
+    z15.string(),
+    z15.object({
+      apiKey: z15.string().optional(),
+      defaultModel: z15.string().optional(),
+      defaultParameters: z15.record(z15.string(), z15.any()).optional()
     })
   ).optional(),
-  defaultProvider: z.string().optional(),
-  defaultModel: z.string().optional(),
-  defaultParameters: z.record(z.string(), z.any()).optional(),
-  maxMessageCount: z.number().int().positive().optional(),
-  budget: z.number().positive().optional(),
-  retryCount: z.number().int().min(0).optional(),
-  requestTimeoutSeconds: z.number().int().positive().optional(),
-  scripts: z.record(
-    z.string(),
-    z.string().or(
-      z.object({
-        command: z.string(),
-        description: z.string()
+  defaultProvider: z15.string().optional(),
+  defaultModel: z15.string().optional(),
+  defaultParameters: z15.record(z15.string(), z15.any()).optional(),
+  toolFormat: toolFormatSchema,
+  maxMessageCount: z15.number().int().positive().optional(),
+  budget: z15.number().positive().optional(),
+  retryCount: z15.number().int().min(0).optional(),
+  requestTimeoutSeconds: z15.number().int().positive().optional(),
+  scripts: z15.record(
+    z15.string(),
+    z15.string().or(
+      z15.object({
+        command: z15.string(),
+        description: z15.string()
       })
     )
   ).optional(),
-  agents: z.record(z.string(), agentSchema).optional(),
-  commands: z.object({
+  agents: z15.record(z15.string(), agentSchema).optional(),
+  commands: z15.object({
     default: providerModelSchema.optional()
   }).catchall(providerModelSchema).optional(),
-  rules: z.array(z.string()).optional().or(z.string()).optional(),
-  excludeFiles: z.array(z.string()).optional(),
-  policies: z.array(z.string()).optional()
+  rules: z15.array(z15.string()).optional().or(z15.string()).optional(),
+  excludeFiles: z15.array(z15.string()).optional(),
+  policies: z15.array(z15.string()).optional()
 }).strict();
 var Policies = /* @__PURE__ */ ((Policies2) => {
-  Policies2["KnowledgeManagement"] = "knowledgemanagement";
   Policies2["TruncateContext"] = "truncatecontext";
+  Policies2["EnableCache"] = "enablecache";
   return Policies2;
 })(Policies || {});
 
-// src/Agent/policies/KnowledgeManagement.ts
-var prompt = `
-====
-
-# Knowledge Extraction & Maintenance
-
-You are equipped with **Knowledge Management** capabilities:
-
-1. **What to capture**
-   - Public API of each file (public classes, functions, methods, parameters, return types).
-   - High-level description of each file's purpose.
-   - Invariants and assumptions that must always hold.
-   - Project or directory-specific coding patterns, styles, and architectural conventions.
-   - Any other insight that a future contributor would find crucial.
-
-2. **Where to store it**
-   - Save knowledge in a YAML file named \`knowledge.ai.yml\`.
-   - **Create the file in the repository root if it does not yet exist.**
-   - One file per directory.
-     - The repository root file records knowledge that applies project-wide (e.g., service responsibilities, global patterns).
-     - Each sub-directory keeps only the knowledge relevant to that directory or package.
-   - Use clear top-level keys such as \`description\`, \`files\`, \`rules\`.
-
-3. **When to update**
-   - **Default behaviour:** only create / update knowledge for the files you actively read, create, or modify during the current task.
-     - Operate on other files **only if the user explicitly requests it**.
-   - **While working**: after reading, analysing, creating, or modifying code, immediately record any new or changed knowledge.
-   - **On refactor / deletion**: locate and delete or amend obsolete entries so that knowledge never drifts from the codebase.
-   - **Granularity**: update only the affected directory's \`knowledge.ai.yml\`, except when the change has global impact.
-
-4. **How to format (illustrative)**
-\`\`\`yaml
-description: "description of the directory"
-files:
-  "math.ts":
-    description: "Numeric helpers for currency calculations"
-    api:
-      functions:
-        1: add(a: number, b: number): number
-rules:
-  1: "rules that apply to all files in this directory"
-\`\`\`
-
-5. **Source of truth**
-   - **Never invent knowledge.** Everything you record must be *directly derived* from existing code, comments, commit messages, or explicit user instructions.
-   - If a section has no confirmed content, omit it rather than guessing.
-
-6. **Automatic context**
-   When you are asked to read or modify a file, the orchestration layer will supply any existing knowledge for that path automatically. Use it, refine it, and keep it accurate.
-
-7. **Using the updateKnowledge tool**
-   You can use the \`updateKnowledge\` tool to efficiently update knowledge files with smart merging capabilities.
-
-8. **Dictionary-First Format**
-   - **Always prefer dictionaries** for structured data.
-   - The **\`files\` section must be a dictionary keyed by file path** (e.g., \`"math.ts": {...}\`).
-   - For other lists (rules, functions, etc.), use numbered dictionaries.
-   - Arrays are allowed only when strict ordering is essential and dictionaries cannot express it.
-   - When removing items, refer to them by their numeric key or index; gaps are fine.
-
-Your workflow **must**:
-   1. Detect knowledge deltas.
-   2. Create \`knowledge.ai.yml\` if missing and write edits to the correct file.
-   3. Remove stale facts.
-   4. Use provided tools to update the knowledge files.
-   5. Record only evidence-based information; do not hallucinate.
-   6. Use dictionaries throughout, with numbered dictionaries for ordered data and path-keyed dictionaries for the \`files\` section.
-`;
-var KnowledgeManagementPolicy = (tools) => {
-  if (!tools[readFile_default.name]) {
-    return void 0;
-  }
-  const readFiles = /* @__PURE__ */ new Set();
-  return {
-    name: "knowledgemanagement" /* KnowledgeManagement */,
-    tools: tools[writeToFile_default.name] ? [updateKnowledge_default] : [],
-    prompt: tools[writeToFile_default.name] || tools[updateKnowledge_default.name] ? prompt : void 0,
-    async getKnowledgeFilePaths(inputFiles) {
-      const paths = /* @__PURE__ */ new Set();
-      for (const file of inputFiles) {
-        let dir = dirname(file);
-        paths.add(dir);
-        while (dir !== ".") {
-          paths.add(dir);
-          dir = dirname(dir);
-        }
-      }
-      const allFullPaths = [];
-      for (const path of paths) {
-        if (path === ".") {
-          continue;
-        }
-        const fullpath = join(path, "knowledge.ai.yml");
-        if (!readFiles.has(fullpath)) {
-          allFullPaths.push(fullpath);
-          readFiles.add(fullpath);
-        }
-      }
-      return allFullPaths;
-    },
-    async updateResponse(response) {
-      const files = /* @__PURE__ */ new Set();
-      for (const content of response) {
-        if (content.type === "tool_use") {
-          switch (content.name) {
-            case readFile_default.name: {
-              const paths = getStringArray(content.params, "path");
-              for (const path of paths) {
-                files.add(path);
-              }
-              break;
-            }
-            case listFiles_default.name: {
-              const path = getString(content.params, "path");
-              files.add(path);
-              break;
-            }
-          }
-        }
-      }
-      const allFullPaths = await this.getKnowledgeFilePaths(Array.from(files));
-      if (allFullPaths.length === 0) {
-        return response;
-      }
-      return [
-        ...response,
-        {
-          type: "tool_use",
-          name: readFile_default.name,
-          params: {
-            path: allFullPaths.join(",")
-          }
-        }
-      ];
-    }
-  };
-};
-
-// src/Agent/policies/TruncateContext.ts
-var DEFAULT_MAX_TOKENS_ESTIMATE = 8e3;
+// src/Agent/policies/TruncateContextPolicy.ts
+var DEFAULT_MAX_TOKENS_ESTIMATE = 32e3;
 function getMaxTokens(agent) {
   const params = agent.parameters || {};
   if (params.maxTokens && typeof params.maxTokens === "number" && params.maxTokens > 0) {
@@ -4024,7 +2808,22 @@ function getMaxTokens(agent) {
 function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
-var TruncateContextPolicy = (tools) => {
+function estimateMessageTokens(msg) {
+  if (typeof msg.content === "string") {
+    return estimateTokens(msg.content);
+  }
+  if (Array.isArray(msg.content)) {
+    let messageTokens = 0;
+    for (const block of msg.content) {
+      if (typeof block === "object" && "text" in block && typeof block.text === "string") {
+        messageTokens += estimateTokens(block.text);
+      }
+    }
+    return messageTokens;
+  }
+  return 0;
+}
+var TruncateContextPolicy = () => {
   return {
     name: "truncatecontext" /* TruncateContext */,
     async onBeforeRequest(agent) {
@@ -4032,52 +2831,128 @@ var TruncateContextPolicy = (tools) => {
       if (messages.length < 3) {
         return;
       }
-      let totalTokens = 0;
-      for (const msg of messages) {
-        if (typeof msg.content === "string") {
-          totalTokens += estimateTokens(msg.content);
-        } else if (Array.isArray(msg.content)) {
-          for (const block of msg.content) {
-            if (typeof block === "object" && "text" in block && typeof block.text === "string") {
-              totalTokens += estimateTokens(block.text);
-            }
-          }
-        }
-      }
+      let totalTokens = messages.reduce((acc, msg) => acc + estimateMessageTokens(msg), 0);
       const maxTokens = getMaxTokens(agent);
       if (totalTokens <= maxTokens) {
         return;
       }
-      const totalMessages = messages.length;
-      const messagesToKeep = Math.ceil(totalMessages / 2);
-      const minKeep = Math.max(2, messagesToKeep);
-      if (minKeep >= totalMessages) {
+      const protectedIndices = /* @__PURE__ */ new Set();
+      let userMessagesFound = 0;
+      messages.forEach((msg, index) => {
+        if (msg.role === "system") {
+          protectedIndices.add(index);
+        }
+        if (msg.role === "user") {
+          if (userMessagesFound < 2) {
+            protectedIndices.add(index);
+          }
+          userMessagesFound++;
+        }
+      });
+      if (messages.length > 0) {
+        protectedIndices.add(messages.length - 1);
+      }
+      const truncatableIndices = [];
+      for (let i = 0; i < messages.length; i++) {
+        if (!protectedIndices.has(i)) {
+          truncatableIndices.push(i);
+        }
+      }
+      const removedIndices = /* @__PURE__ */ new Set();
+      const initialTotalTokens = totalTokens;
+      while (totalTokens > maxTokens && truncatableIndices.length > 0) {
+        const middleIndex = Math.floor(truncatableIndices.length / 2);
+        const indexToRemove = truncatableIndices.splice(middleIndex, 1)[0];
+        removedIndices.add(indexToRemove);
+        totalTokens -= estimateMessageTokens(messages[indexToRemove]);
+      }
+      if (removedIndices.size === 0) {
+        if (initialTotalTokens > maxTokens) {
+          console.warn("Warning: Protected messages exceed token limit. Cannot truncate further.");
+        }
         return;
       }
-      const keepFromStart = Math.floor(minKeep / 2);
-      const keepFromEnd = minKeep - keepFromStart;
-      const startMessages = messages.slice(0, keepFromStart);
-      const endMessages = messages.slice(-keepFromEnd);
-      const truncatedCount = totalMessages - minKeep;
-      const truncatedMessages = [
-        ...startMessages,
-        // Add a message explaining truncation
-        {
-          role: "user",
-          content: `Note: ${truncatedCount} messages were truncated from the middle to prevent context overflow.`
-        },
-        ...endMessages
-      ];
+      const truncatedMessages = [];
+      let truncationNoticeAdded = false;
+      for (let i = 0; i < messages.length; i++) {
+        if (removedIndices.has(i)) {
+          if (!truncationNoticeAdded) {
+            truncatedMessages.push({
+              role: "user",
+              content: `Note: ${removedIndices.size} messages were truncated from the conversation to prevent context overflow.`
+            });
+            truncationNoticeAdded = true;
+          }
+        } else {
+          truncatedMessages.push(messages[i]);
+        }
+      }
+      console.log(`Truncated context: removed ${removedIndices.size} messages.`);
       agent.setMessages(truncatedMessages);
     }
   };
 };
 
+// src/Agent/policies/EnableCachePolicy.ts
+var CACHEABLE_MODELS = ["sonnet", "opus", "haiku", "gemini"];
+function isCacheableModel(modelId) {
+  return CACHEABLE_MODELS.some((model) => modelId.includes(model));
+}
+function getProviderKey(provider) {
+  if (provider === "openrouter") {
+    return "openrouter";
+  }
+  if (provider.includes("anthropic")) {
+    return "anthropic";
+  }
+  return void 0;
+}
+var EnableCachePolicy = () => {
+  return {
+    name: "enablecache" /* EnableCache */,
+    async prepareMessages(agent, messages) {
+      const providerKey = getProviderKey(agent.ai.provider);
+      if (!providerKey || !isCacheableModel(agent.ai.modelId)) {
+        return messages;
+      }
+      const providerOptions = { [providerKey]: { cacheControl: { type: "ephemeral" } } };
+      const newMessages = messages.slice();
+      let userMessagesToUpdate = 2;
+      for (let i = newMessages.length - 1; i >= 0; i--) {
+        const message = newMessages[i];
+        if (message.role === "user" && userMessagesToUpdate > 0) {
+          newMessages[i] = {
+            ...message,
+            providerOptions: {
+              ...providerOptions,
+              ...message.providerOptions ?? {}
+            }
+          };
+          userMessagesToUpdate--;
+        } else if (message.role === "system") {
+          newMessages[i] = {
+            ...message,
+            providerOptions: {
+              ...providerOptions,
+              ...message.providerOptions ?? {}
+            }
+          };
+          break;
+        }
+      }
+      return newMessages;
+    }
+  };
+};
+
 // src/Agent/index.ts
 var allAgents = [architectAgentInfo, coderAgentInfo, analyzerAgentInfo, codeFixerAgentInfo];
 
+// src/AiTool/index.ts
+import { generateText } from "ai";
+
 // src/AiTool/createNewProject.ts
-var prompt2 = `You are an AiTool designed to assist users in creating new projects. Follow these guidelines:
+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:
@@ -4162,7 +3037,7 @@ var prompt2 = `You are an AiTool designed to assist users in creating new projec
 var createNewProject_default = {
   name: "createNewProject",
   description: "Creates a new project",
-  prompt: prompt2,
+  prompt,
   formatInput: (params) => {
     return `<project_name>${params}</project_name>`;
   },
@@ -4173,7 +3048,7 @@ var createNewProject_default = {
 };
 
 // src/AiTool/generateGitCommitMessage.ts
-var prompt3 = `
+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).
@@ -4204,7 +3079,7 @@ Follow the same structure for any new input. Never repeat questions; focus on ge
 var generateGitCommitMessage_default = {
   name: "generateGitCommitMessage",
   description: "Generates git commit messages from git diff output",
-  prompt: prompt3,
+  prompt: prompt2,
   formatInput: (params) => {
     let ret = `<tool_input>
 ${params.diff}
@@ -4229,7 +3104,7 @@ ${output}`);
 };
 
 // src/AiTool/generateGithubPullRequestDetails.ts
-var prompt4 = `
+var prompt3 = `
 # Generate Github Pull Request Details
 
 You are given:
@@ -4313,7 +3188,7 @@ Use the above format whenever you receive <tool_input> that may include a branch
 var generateGithubPullRequestDetails_default = {
   name: "generateGithubPullRequestDetails",
   description: "Generates a GitHub pull request title and description from git commits",
-  prompt: prompt4,
+  prompt: prompt3,
   formatInput: (params) => {
     return `<tool_input>
 <tool_input_branch_name>${params.branchName}</tool_input_branch_name>${params.context ? `
@@ -4346,7 +3221,7 @@ ${output}`);
 };
 
 // src/AiTool/generateProjectConfig.ts
-var prompt5 = `
+var prompt4 = `
 Role: Analyzer agent
 Goal: Produce a valid polkacodes YAML configuration for the project.
 
@@ -4393,7 +3268,7 @@ excludeFiles:     # only files likely to hold secrets
 var generateProjectConfig_default = {
   name: "generateProjectConfig",
   description: "Analyzes project files to generate polkacodes config sections",
-  prompt: prompt5,
+  prompt: prompt4,
   formatInput: () => {
     return "";
   },
@@ -4404,14 +3279,19 @@ var generateProjectConfig_default = {
 };
 
 // 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 executeTool = async (definition, ai, params, usageMeter) => {
+  const resp = await generateText({
+    model: ai,
+    system: definition.prompt,
+    messages: [
+      {
+        role: "user",
+        content: definition.formatInput(params)
+      }
+    ]
+  });
+  usageMeter.addUsage(ai, resp);
+  return definition.parseOutput(resp.text);
 };
 var executeAgentTool = async (definition, agent, params) => {
   if (!definition.agent) {
@@ -4428,8 +3308,8 @@ var executeAgentTool = async (definition, agent, params) => {
   throw new Error(`Tool execution failed: ${exitReason.type}`);
 };
 var makeTool = (definition) => {
-  return async (ai, params) => {
-    return executeTool(definition, ai, params);
+  return async (ai, params, usageMeter) => {
+    return executeTool(definition, ai, params, usageMeter);
   };
 };
 var makeAgentTool = (definition) => {
@@ -4443,13 +3323,11 @@ var generateProjectConfig = makeAgentTool(generateProjectConfig_default);
 var createNewProject = makeAgentTool(createNewProject_default);
 export {
   AgentBase,
-  AiServiceBase,
-  AiServiceProvider,
   AnalyzerAgent,
   ArchitectAgent,
   CodeFixerAgent,
   CoderAgent,
-  KnowledgeManagementPolicy,
+  EnableCachePolicy,
   MockProvider,
   MultiAgent,
   PermissionLevel,
@@ -4462,8 +3340,6 @@ export {
   allAgents,
   allTools_exports as allTools,
   analyzerAgentInfo,
-  anthropicDefaultModelId,
-  anthropicModels,
   architectAgentInfo,
   askFollowupQuestion_default as askFollowupQuestion,
   attemptCompletion_default as attemptCompletion,
@@ -4472,12 +3348,8 @@ export {
   coderAgentInfo,
   configSchema,
   createNewProject,
-  createService,
   customInstructions,
   customScripts,
-  deepSeekDefaultModelId,
-  deepSeekModels,
-  defaultModels,
   delegate_default as delegate,
   executeAgentTool,
   executeCommand_default as executeCommand,
@@ -4486,18 +3358,11 @@ export {
   generateGitCommitMessage,
   generateGithubPullRequestDetails,
   generateProjectConfig,
-  getArray,
   getAvailableTools,
-  getBoolean,
-  getInt,
-  getString,
-  getStringArray,
   handOver_default as handOver,
   listFiles_default as listFiles,
   makeAgentTool,
   makeTool,
-  modelInfos,
-  openAiModelInfoSaneDefaults,
   parseAssistantMessage,
   readFile_default as readFile,
   removeFile_default as removeFile,
@@ -4508,6 +3373,5 @@ export {
   searchFiles_default as searchFiles,
   systemInformation,
   toolUsePrompt,
-  updateKnowledge_default as updateKnowledge,
   writeToFile_default as writeToFile
 };