@corbat-tech/coco 2.23.0 → 2.24.0

package/dist/index.js

@@ -13072,6 +13072,147 @@ function createKimiCodeProvider(config) {
 
 // src/providers/openai.ts
 init_errors();
+function getSingleBuilderKey(builders) {
+  return builders.size === 1 ? Array.from(builders.keys())[0] ?? null : null;
+}
+function parseToolCallArguments(args, providerName) {
+  try {
+    return args ? JSON.parse(args) : {};
+  } catch {
+    try {
+      if (args) {
+        const repaired = jsonrepair(args);
+        return JSON.parse(repaired);
+      }
+    } catch {
+      console.error(`[${providerName}] Cannot parse tool arguments: ${args.slice(0, 200)}`);
+    }
+    return {};
+  }
+}
+var ChatToolCallAssembler = class {
+  builders = /* @__PURE__ */ new Map();
+  lastBuilderKey = null;
+  consume(delta) {
+    const key = typeof delta.index === "number" ? `index:${delta.index}` : typeof delta.id === "string" && delta.id.length > 0 ? `id:${delta.id}` : getSingleBuilderKey(this.builders) ?? this.lastBuilderKey ?? `fallback:${this.builders.size}`;
+    let started;
+    if (!this.builders.has(key)) {
+      const initialId = delta.id ?? "";
+      const initialName = delta.function?.name ?? "";
+      this.builders.set(key, { id: initialId, name: initialName, arguments: "" });
+      started = {
+        id: initialId || void 0,
+        name: initialName || void 0
+      };
+    }
+    const builder = this.builders.get(key);
+    this.lastBuilderKey = key;
+    if (delta.id) {
+      builder.id = delta.id;
+    }
+    if (delta.function?.name) {
+      builder.name = delta.function.name;
+    }
+    const text = delta.function?.arguments ?? "";
+    if (!text) return { started };
+    builder.arguments += text;
+    return {
+      started,
+      argumentDelta: {
+        id: builder.id,
+        name: builder.name,
+        text
+      }
+    };
+  }
+  finalizeAll(providerName) {
+    const result = [];
+    for (const builder of this.builders.values()) {
+      result.push({
+        id: builder.id,
+        name: builder.name,
+        input: parseToolCallArguments(builder.arguments, providerName)
+      });
+    }
+    this.builders.clear();
+    this.lastBuilderKey = null;
+    return result;
+  }
+};
+var ResponsesToolCallAssembler = class {
+  builders = /* @__PURE__ */ new Map();
+  outputIndexToBuilderKey = /* @__PURE__ */ new Map();
+  onOutputItemAdded(event) {
+    const item = event.item;
+    if (!item || item.type !== "function_call") return null;
+    const callId = item.call_id ?? "";
+    const itemKey = item.id ?? callId;
+    this.builders.set(itemKey, {
+      callId,
+      name: item.name ?? "",
+      arguments: item.arguments ?? ""
+    });
+    if (typeof event.output_index === "number") {
+      this.outputIndexToBuilderKey.set(event.output_index, itemKey);
+    }
+    return {
+      id: callId,
+      name: item.name ?? ""
+    };
+  }
+  onArgumentsDelta(event) {
+    const builderKey = this.resolveBuilderKey(event.item_id, event.output_index);
+    if (!builderKey) return;
+    const builder = this.builders.get(builderKey);
+    if (!builder) return;
+    builder.arguments += event.delta ?? "";
+  }
+  onArgumentsDone(event, providerName) {
+    const builderKey = this.resolveBuilderKey(event.item_id, event.output_index);
+    if (!builderKey) return null;
+    const builder = this.builders.get(builderKey);
+    if (!builder) return null;
+    const toolCall = {
+      id: builder.callId,
+      name: builder.name,
+      input: parseToolCallArguments(event.arguments ?? builder.arguments, providerName)
+    };
+    this.deleteBuilder(builderKey);
+    return toolCall;
+  }
+  finalizeAll(providerName) {
+    const calls = [];
+    for (const builder of this.builders.values()) {
+      calls.push({
+        id: builder.callId,
+        name: builder.name,
+        input: parseToolCallArguments(builder.arguments, providerName)
+      });
+    }
+    this.builders.clear();
+    this.outputIndexToBuilderKey.clear();
+    return calls;
+  }
+  resolveBuilderKey(itemId, outputIndex) {
+    if (itemId && this.builders.has(itemId)) {
+      return itemId;
+    }
+    if (typeof outputIndex === "number") {
+      return this.outputIndexToBuilderKey.get(outputIndex) ?? null;
+    }
+    return getSingleBuilderKey(this.builders);
+  }
+  deleteBuilder(builderKey) {
+    this.builders.delete(builderKey);
+    for (const [idx, key] of this.outputIndexToBuilderKey.entries()) {
+      if (key === builderKey) {
+        this.outputIndexToBuilderKey.delete(idx);
+      }
+    }
+  }
+};
+
+// src/providers/openai.ts
 var DEFAULT_MODEL2 = "gpt-5.4-codex";
 var CONTEXT_WINDOWS2 = {
   // OpenAI models
@@ -13411,7 +13552,7 @@ var OpenAIProvider = class {
       const stream = await this.client.chat.completions.create(
         requestParams
       );
-      const toolCallBuilders = /* @__PURE__ */ new Map();
+      const toolCallAssembler = new ChatToolCallAssembler();
       const streamTimeout = this.config.timeout ?? 12e4;
       let lastActivityTime = Date.now();
       const timeoutController = new AbortController();
@@ -13425,30 +13566,6 @@ var OpenAIProvider = class {
       timeoutController.signal.addEventListener("abort", () => stream.controller.abort(), {
         once: true
       });
-      const providerName = this.name;
-      const parseArguments2 = (builder) => {
-        let input = {};
-        try {
-          input = builder.arguments ? JSON.parse(builder.arguments) : {};
-        } catch (error) {
-          console.warn(
-            `[${providerName}] Failed to parse tool call arguments for ${builder.name}: ${builder.arguments?.slice(0, 300)}`
-          );
-          try {
-            if (builder.arguments) {
-              const repaired = jsonrepair(builder.arguments);
-              input = JSON.parse(repaired);
-              console.log(`[${providerName}] \u2713 Successfully repaired JSON for ${builder.name}`);
-            }
-          } catch {
-            console.error(
-              `[${providerName}] Cannot repair JSON for ${builder.name}, using empty object`
-            );
-            console.error(`[${providerName}] Original error:`, error);
-          }
-        }
-        return input;
-      };
       try {
         let streamStopReason;
         for await (const chunk of stream) {
@@ -13461,37 +13578,31 @@ var OpenAIProvider = class {
           }
           if (delta?.tool_calls) {
             for (const toolCallDelta of delta.tool_calls) {
-              const index = toolCallDelta.index ?? toolCallBuilders.size;
-              if (!toolCallBuilders.has(index)) {
-                toolCallBuilders.set(index, {
-                  id: toolCallDelta.id ?? "",
-                  name: toolCallDelta.function?.name ?? "",
-                  arguments: ""
-                });
+              const consumed = toolCallAssembler.consume({
+                index: toolCallDelta.index,
+                id: toolCallDelta.id ?? void 0,
+                function: {
+                  name: toolCallDelta.function?.name ?? void 0,
+                  arguments: toolCallDelta.function?.arguments ?? void 0
+                }
+              });
+              if (consumed.started) {
                 yield {
                   type: "tool_use_start",
                   toolCall: {
-                    id: toolCallDelta.id,
-                    name: toolCallDelta.function?.name
+                    id: consumed.started.id,
+                    name: consumed.started.name
                   }
                 };
               }
-              const builder = toolCallBuilders.get(index);
-              if (toolCallDelta.id) {
-                builder.id = toolCallDelta.id;
-              }
-              if (toolCallDelta.function?.name) {
-                builder.name = toolCallDelta.function.name;
-              }
-              if (toolCallDelta.function?.arguments) {
-                builder.arguments += toolCallDelta.function.arguments;
+              if (consumed.argumentDelta) {
                 yield {
                   type: "tool_use_delta",
                   toolCall: {
-                    id: builder.id,
-                    name: builder.name
+                    id: consumed.argumentDelta.id,
+                    name: consumed.argumentDelta.name
                   },
-                  text: toolCallDelta.function.arguments
+                  text: consumed.argumentDelta.text
                 };
               }
             }
@@ -13500,27 +13611,26 @@ var OpenAIProvider = class {
           if (finishReason) {
             streamStopReason = this.mapFinishReason(finishReason);
           }
-          if (finishReason && toolCallBuilders.size > 0) {
-            for (const [, builder] of toolCallBuilders) {
+          if (finishReason) {
+            for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
               yield {
                 type: "tool_use_end",
                 toolCall: {
-                  id: builder.id,
-                  name: builder.name,
-                  input: parseArguments2(builder)
+                  id: toolCall.id,
+                  name: toolCall.name,
+                  input: toolCall.input
                 }
               };
             }
-            toolCallBuilders.clear();
           }
         }
-        for (const [, builder] of toolCallBuilders) {
+        for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
           yield {
             type: "tool_use_end",
             toolCall: {
-              id: builder.id,
-              name: builder.name,
-              input: parseArguments2(builder)
+              id: toolCall.id,
+              name: toolCall.name,
+              input: toolCall.input
             }
           };
         }
@@ -13957,7 +14067,7 @@ var OpenAIProvider = class {
             toolCalls.push({
               id: item.call_id,
               name: item.name,
-              input: this.parseResponsesArguments(item.arguments)
+              input: parseToolCallArguments(item.arguments, this.name)
             });
           }
         }
@@ -14063,7 +14173,7 @@ var OpenAIProvider = class {
       const stream = await this.client.responses.create(
         requestParams
       );
-      const fnCallBuilders = /* @__PURE__ */ new Map();
+      const toolCallAssembler = new ResponsesToolCallAssembler();
       const streamTimeout = this.config.timeout ?? 12e4;
       let lastActivityTime = Date.now();
       const timeoutController = new AbortController();
@@ -14087,57 +14197,66 @@ var OpenAIProvider = class {
               yield { type: "text", text: event.delta };
               break;
             case "response.output_item.added":
-              if (event.item.type === "function_call") {
-                const fc = event.item;
-                const itemKey = fc.id ?? fc.call_id;
-                fnCallBuilders.set(itemKey, {
-                  callId: fc.call_id,
-                  name: fc.name,
-                  arguments: ""
+              {
+                const item = event.item;
+                const start = toolCallAssembler.onOutputItemAdded({
+                  output_index: event.output_index,
+                  item: {
+                    type: item.type,
+                    id: item.id,
+                    call_id: item.call_id,
+                    name: item.name,
+                    arguments: item.arguments
+                  }
                 });
+                if (!start) break;
                 yield {
                   type: "tool_use_start",
-                  toolCall: { id: fc.call_id, name: fc.name }
+                  toolCall: { id: start.id, name: start.name }
                 };
               }
               break;
             case "response.function_call_arguments.delta":
-              {
-                const builder = fnCallBuilders.get(event.item_id);
-                if (builder) {
-                  builder.arguments += event.delta;
-                }
-              }
+              toolCallAssembler.onArgumentsDelta({
+                item_id: event.item_id,
+                output_index: event.output_index,
+                delta: event.delta
+              });
               break;
             case "response.function_call_arguments.done":
               {
-                const builder = fnCallBuilders.get(event.item_id);
-                if (builder) {
+                const toolCall = toolCallAssembler.onArgumentsDone(
+                  {
+                    item_id: event.item_id,
+                    output_index: event.output_index,
+                    arguments: event.arguments
+                  },
+                  this.name
+                );
+                if (toolCall) {
                   yield {
                     type: "tool_use_end",
                     toolCall: {
-                      id: builder.callId,
-                      name: builder.name,
-                      input: this.parseResponsesArguments(event.arguments)
+                      id: toolCall.id,
+                      name: toolCall.name,
+                      input: toolCall.input
                     }
                   };
-                  fnCallBuilders.delete(event.item_id);
                 }
               }
               break;
             case "response.completed":
               {
-                for (const [, builder] of fnCallBuilders) {
+                for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
                   yield {
                     type: "tool_use_end",
                     toolCall: {
-                      id: builder.callId,
-                      name: builder.name,
-                      input: this.parseResponsesArguments(builder.arguments)
+                      id: toolCall.id,
+                      name: toolCall.name,
+                      input: toolCall.input
                     }
                   };
                 }
-                fnCallBuilders.clear();
                 const hasToolCalls = event.response.output.some(
                   (i) => i.type === "function_call"
                 );
@@ -14257,24 +14376,6 @@ var OpenAIProvider = class {
       strict: false
     }));
   }
-  /**
-   * Parse tool call arguments with jsonrepair fallback (Responses API)
-   */
-  parseResponsesArguments(args) {
-    try {
-      return args ? JSON.parse(args) : {};
-    } catch {
-      try {
-        if (args) {
-          const repaired = jsonrepair(args);
-          return JSON.parse(repaired);
-        }
-      } catch {
-        console.error(`[${this.name}] Cannot parse tool arguments: ${args.slice(0, 200)}`);
-      }
-      return {};
-    }
-  }
 };
 function createKimiProvider(config) {
   const provider = new OpenAIProvider("kimi", "Kimi (Moonshot)");
@@ -14322,21 +14423,6 @@ function extractAccountId(accessToken) {
   const auth = claims["https://api.openai.com/auth"];
   return claims["chatgpt_account_id"] || auth?.["chatgpt_account_id"] || claims["organizations"]?.[0]?.id;
 }
-function parseArguments(args) {
-  try {
-    return args ? JSON.parse(args) : {};
-  } catch {
-    try {
-      if (args) {
-        const repaired = jsonrepair(args);
-        return JSON.parse(repaired);
-      }
-    } catch {
-      console.error(`[Codex] Cannot parse tool arguments: ${args.slice(0, 200)}`);
-    }
-    return {};
-  }
-}
 var CodexProvider = class {
   id = "codex";
   name = "OpenAI Codex (ChatGPT Plus/Pro)";
@@ -14636,7 +14722,7 @@ var CodexProvider = class {
       let inputTokens = 0;
       let outputTokens = 0;
       const toolCalls = [];
-      const fnCallBuilders = /* @__PURE__ */ new Map();
+      const toolCallAssembler = new ResponsesToolCallAssembler();
       await this.readSSEStream(response, (event) => {
         if (event.id) responseId = event.id;
         switch (event.type) {
@@ -14647,31 +14733,35 @@ var CodexProvider = class {
             content = event.text ?? content;
             break;
           case "response.output_item.added": {
-            const item = event.item;
-            if (item.type === "function_call") {
-              const itemKey = item.id ?? item.call_id;
-              fnCallBuilders.set(itemKey, {
-                callId: item.call_id,
-                name: item.name,
-                arguments: ""
-              });
-            }
+            toolCallAssembler.onOutputItemAdded({
+              output_index: event.output_index,
+              item: event.item
+            });
             break;
           }
           case "response.function_call_arguments.delta": {
-            const builder = fnCallBuilders.get(event.item_id);
-            if (builder) builder.arguments += event.delta ?? "";
+            toolCallAssembler.onArgumentsDelta({
+              item_id: event.item_id,
+              output_index: event.output_index,
+              delta: event.delta
+            });
             break;
           }
           case "response.function_call_arguments.done": {
-            const builder = fnCallBuilders.get(event.item_id);
-            if (builder) {
+            const toolCall = toolCallAssembler.onArgumentsDone(
+              {
+                item_id: event.item_id,
+                output_index: event.output_index,
+                arguments: event.arguments
+              },
+              this.name
+            );
+            if (toolCall) {
               toolCalls.push({
-                id: builder.callId,
-                name: builder.name,
-                input: parseArguments(event.arguments)
+                id: toolCall.id,
+                name: toolCall.name,
+                input: toolCall.input
               });
-              fnCallBuilders.delete(event.item_id);
             }
             break;
           }
@@ -14682,14 +14772,13 @@ var CodexProvider = class {
               inputTokens = usage.input_tokens ?? 0;
               outputTokens = usage.output_tokens ?? 0;
             }
-            for (const [, builder] of fnCallBuilders) {
+            for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
               toolCalls.push({
-                id: builder.callId,
-                name: builder.name,
-                input: parseArguments(builder.arguments)
+                id: toolCall.id,
+                name: toolCall.name,
+                input: toolCall.input
               });
             }
-            fnCallBuilders.clear();
             break;
           }
         }
@@ -14783,7 +14872,7 @@ var CodexProvider = class {
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    const fnCallBuilders = /* @__PURE__ */ new Map();
+    const toolCallAssembler = new ResponsesToolCallAssembler();
     let lastActivityTime = Date.now();
     const timeoutController = new AbortController();
     const timeoutInterval = setInterval(() => {
@@ -14816,55 +14905,58 @@ var CodexProvider = class {
               yield { type: "text", text: event.delta ?? "" };
               break;
             case "response.output_item.added": {
-              const item = event.item;
-              if (item.type === "function_call") {
-                const itemKey = item.id ?? item.call_id;
-                fnCallBuilders.set(itemKey, {
-                  callId: item.call_id,
-                  name: item.name,
-                  arguments: ""
-                });
+              const start = toolCallAssembler.onOutputItemAdded({
+                output_index: event.output_index,
+                item: event.item
+              });
+              if (start) {
                 yield {
                   type: "tool_use_start",
-                  toolCall: { id: item.call_id, name: item.name }
+                  toolCall: { id: start.id, name: start.name }
                 };
               }
               break;
             }
             case "response.function_call_arguments.delta": {
-              const builder = fnCallBuilders.get(event.item_id);
-              if (builder) {
-                builder.arguments += event.delta ?? "";
-              }
+              toolCallAssembler.onArgumentsDelta({
+                item_id: event.item_id,
+                output_index: event.output_index,
+                delta: event.delta
+              });
               break;
             }
             case "response.function_call_arguments.done": {
-              const builder = fnCallBuilders.get(event.item_id);
-              if (builder) {
+              const toolCall = toolCallAssembler.onArgumentsDone(
+                {
+                  item_id: event.item_id,
+                  output_index: event.output_index,
+                  arguments: event.arguments
+                },
+                this.name
+              );
+              if (toolCall) {
                 yield {
                   type: "tool_use_end",
                   toolCall: {
-                    id: builder.callId,
-                    name: builder.name,
-                    input: parseArguments(event.arguments ?? builder.arguments)
+                    id: toolCall.id,
+                    name: toolCall.name,
+                    input: toolCall.input
                   }
                 };
-                fnCallBuilders.delete(event.item_id);
               }
               break;
             }
             case "response.completed": {
-              for (const [, builder] of fnCallBuilders) {
+              for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
                 yield {
                   type: "tool_use_end",
                   toolCall: {
-                    id: builder.callId,
-                    name: builder.name,
-                    input: parseArguments(builder.arguments)
+                    id: toolCall.id,
+                    name: toolCall.name,
+                    input: toolCall.input
                   }
                 };
               }
-              fnCallBuilders.clear();
               const resp = event.response;
               const output = resp?.output ?? [];
               const hasToolCalls = output.some((i) => i.type === "function_call");
@@ -15222,8 +15314,8 @@ var GeminiProvider = class {
       const { history, lastMessage } = this.convertMessages(messages);
       const chat = model.startChat({ history });
       const result = await chat.sendMessageStream(lastMessage);
-      const emittedToolCalls = /* @__PURE__ */ new Set();
       let streamStopReason;
+      let streamToolCallCounter = 0;
       for await (const chunk of result.stream) {
         const text = chunk.text();
         if (text) {
@@ -15238,30 +15330,23 @@ var GeminiProvider = class {
           for (const part of candidate.content.parts) {
             if ("functionCall" in part && part.functionCall) {
               const funcCall = part.functionCall;
-              const sortedArgs = funcCall.args ? Object.keys(funcCall.args).sort().map(
-                (k) => `${k}:${JSON.stringify(funcCall.args[k])}`
-              ).join(",") : "";
-              const callKey = `${funcCall.name}-${sortedArgs}`;
-              if (!emittedToolCalls.has(callKey)) {
-                emittedToolCalls.add(callKey);
-                const toolCall = {
-                  id: funcCall.name,
-                  // Gemini uses name as ID
-                  name: funcCall.name,
-                  input: funcCall.args ?? {}
-                };
-                yield {
-                  type: "tool_use_start",
-                  toolCall: {
-                    id: toolCall.id,
-                    name: toolCall.name
-                  }
-                };
-                yield {
-                  type: "tool_use_end",
-                  toolCall
-                };
-              }
+              streamToolCallCounter++;
+              const toolCall = {
+                id: `gemini_call_${streamToolCallCounter}`,
+                name: funcCall.name,
+                input: funcCall.args ?? {}
+              };
+              yield {
+                type: "tool_use_start",
+                toolCall: {
+                  id: toolCall.id,
+                  name: toolCall.name
+                }
+              };
+              yield {
+                type: "tool_use_end",
+                toolCall
+              };
             }
           }
         }
@@ -15336,13 +15421,13 @@ var GeminiProvider = class {
    * Convert messages to Gemini format
    */
   convertMessages(messages) {
+    const toolNameByUseId = this.buildToolUseNameMap(messages);
+    const conversation = messages.filter((m) => m.role !== "system");
     const history = [];
     let lastUserMessage = "";
-    for (const msg of messages) {
-      if (msg.role === "system") {
-        continue;
-      }
-      const parts = this.convertContent(msg.content);
+    for (let i = 0; i < conversation.length; i++) {
+      const msg = conversation[i];
+      const isLastMessage = i === conversation.length - 1;
       if (msg.role === "user") {
         if (Array.isArray(msg.content) && msg.content[0]?.type === "tool_result") {
           const functionResponses = [];
@@ -15351,23 +15436,49 @@ var GeminiProvider = class {
               const toolResult = block;
               functionResponses.push({
                 functionResponse: {
-                  name: toolResult.tool_use_id,
-                  // Gemini uses name, we store it in tool_use_id
+                  // Gemini expects the function name in functionResponse.name.
+                  // Recover it from prior assistant tool_use blocks when possible.
+                  name: toolNameByUseId.get(toolResult.tool_use_id) ?? toolResult.tool_use_id,
                   response: { result: toolResult.content }
                 }
               });
             }
           }
-          history.push({ role: "user", parts: functionResponses });
+          if (isLastMessage) {
+            lastUserMessage = functionResponses;
+          } else {
+            history.push({ role: "user", parts: functionResponses });
+          }
         } else {
-          lastUserMessage = parts;
+          const parts = this.convertContent(msg.content);
+          if (isLastMessage) {
+            lastUserMessage = parts;
+          } else {
+            history.push({ role: "user", parts });
+          }
         }
       } else if (msg.role === "assistant") {
+        const parts = this.convertContent(msg.content);
         history.push({ role: "model", parts });
       }
     }
     return { history, lastMessage: lastUserMessage };
   }
+  /**
+   * Build a map from tool_use IDs to function names from assistant history.
+   */
+  buildToolUseNameMap(messages) {
+    const map = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        if (block.type === "tool_use") {
+          map.set(block.id, block.name);
+        }
+      }
+    }
+    return map;
+  }
   /**
    * Convert content to Gemini parts
    */
@@ -15444,14 +15555,15 @@ var GeminiProvider = class {
     let textContent = "";
     const toolCalls = [];
     if (candidate?.content?.parts) {
+      let toolIndex = 0;
       for (const part of candidate.content.parts) {
         if ("text" in part && part.text) {
           textContent += part.text;
         }
         if ("functionCall" in part && part.functionCall) {
+          toolIndex++;
           toolCalls.push({
-            id: part.functionCall.name,
-            // Use name as ID for Gemini
+            id: `gemini_call_${toolIndex}`,
             name: part.functionCall.name,
             input: part.functionCall.args ?? {}
           });
@@ -15510,10 +15622,296 @@ var GeminiProvider = class {
 
 // src/providers/circuit-breaker.ts
 init_errors();
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  failureThreshold: 5,
+  resetTimeout: 3e4,
+  halfOpenRequests: 1
+};
+var CircuitOpenError = class extends ProviderError {
+  remainingTime;
+  constructor(provider, remainingTime) {
+    super(`Circuit breaker is open for provider: ${provider}`, {
+      provider,
+      retryable: true
+    });
+    this.name = "CircuitOpenError";
+    this.remainingTime = remainingTime;
+  }
+};
+var CircuitBreaker = class {
+  config;
+  state = "closed";
+  failureCount = 0;
+  lastFailureTime = null;
+  halfOpenSuccesses = 0;
+  providerId;
+  /**
+   * Create a new circuit breaker
+   *
+   * @param config - Circuit breaker configuration
+   * @param providerId - Provider identifier for error messages
+   */
+  constructor(config, providerId = "unknown") {
+    this.config = { ...DEFAULT_CIRCUIT_BREAKER_CONFIG, ...config };
+    this.providerId = providerId;
+  }
+  /**
+   * Get the current circuit state
+   */
+  getState() {
+    this.checkStateTransition();
+    return this.state;
+  }
+  /**
+   * Check if the circuit is currently open (blocking requests)
+   */
+  isOpen() {
+    this.checkStateTransition();
+    return this.state === "open";
+  }
+  /**
+   * Get the current failure count
+   */
+  getFailureCount() {
+    return this.failureCount;
+  }
+  /**
+   * Record a successful request
+   * Resets failure count in closed state, or counts toward closing in half-open
+   */
+  recordSuccess() {
+    if (this.state === "half-open") {
+      this.halfOpenSuccesses++;
+      if (this.halfOpenSuccesses >= this.config.halfOpenRequests) {
+        this.close();
+      }
+    } else if (this.state === "closed") {
+      this.failureCount = 0;
+    }
+  }
+  /**
+   * Record a failed request
+   * Increments failure count and may open the circuit
+   */
+  recordFailure() {
+    this.lastFailureTime = Date.now();
+    this.failureCount++;
+    if (this.state === "half-open") {
+      this.open();
+    } else if (this.state === "closed" && this.failureCount >= this.config.failureThreshold) {
+      this.open();
+    }
+  }
+  /**
+   * Execute a function with circuit breaker protection
+   *
+   * @param fn - Async function to execute
+   * @returns Result of the function
+   * @throws CircuitOpenError if circuit is open
+   * @throws Original error if function fails
+   */
+  async execute(fn) {
+    this.checkStateTransition();
+    if (this.state === "open") {
+      const elapsed = Date.now() - (this.lastFailureTime ?? Date.now());
+      const remaining = this.config.resetTimeout - elapsed;
+      throw new CircuitOpenError(this.providerId, remaining);
+    }
+    try {
+      const result = await fn();
+      this.recordSuccess();
+      return result;
+    } catch (error) {
+      this.recordFailure();
+      throw error;
+    }
+  }
+  /**
+   * Manually reset the circuit breaker to closed state
+   */
+  reset() {
+    this.close();
+  }
+  /**
+   * Check and perform state transitions based on time
+   */
+  checkStateTransition() {
+    if (this.state === "open" && this.lastFailureTime !== null) {
+      const elapsed = Date.now() - this.lastFailureTime;
+      if (elapsed >= this.config.resetTimeout) {
+        this.halfOpen();
+      }
+    }
+  }
+  /**
+   * Transition to closed state
+   */
+  close() {
+    this.state = "closed";
+    this.failureCount = 0;
+    this.halfOpenSuccesses = 0;
+    this.lastFailureTime = null;
+  }
+  /**
+   * Transition to open state
+   */
+  open() {
+    this.state = "open";
+    this.halfOpenSuccesses = 0;
+  }
+  /**
+   * Transition to half-open state
+   */
+  halfOpen() {
+    this.state = "half-open";
+    this.halfOpenSuccesses = 0;
+  }
+};
 
 // src/providers/fallback.ts
 init_errors();
 
+// src/providers/resilient.ts
+var DEFAULT_STREAM_RETRY = {
+  maxRetries: 1,
+  initialDelayMs: 500,
+  maxDelayMs: 5e3,
+  backoffMultiplier: 2,
+  jitterFactor: 0.1
+};
+function sleep2(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function computeRetryDelay(attempt, config) {
+  const exp = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
+  const capped = Math.min(exp, config.maxDelayMs);
+  const jitter = capped * config.jitterFactor * (Math.random() * 2 - 1);
+  return Math.max(0, Math.min(capped + jitter, config.maxDelayMs));
+}
+var ResilientProvider = class {
+  id;
+  name;
+  provider;
+  breaker;
+  retryConfig;
+  streamRetryConfig;
+  constructor(provider, config = {}) {
+    this.provider = provider;
+    this.id = provider.id;
+    this.name = provider.name;
+    this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...config.retry };
+    this.streamRetryConfig = { ...DEFAULT_STREAM_RETRY, ...config.streamRetry };
+    this.breaker = new CircuitBreaker(
+      { ...DEFAULT_CIRCUIT_BREAKER_CONFIG, ...config.circuitBreaker },
+      provider.id
+    );
+  }
+  async initialize(config) {
+    await this.provider.initialize(config);
+  }
+  async chat(messages, options) {
+    return this.breaker.execute(
+      () => withRetry(() => this.provider.chat(messages, options), this.retryConfig)
+    );
+  }
+  async chatWithTools(messages, options) {
+    return this.breaker.execute(
+      () => withRetry(() => this.provider.chatWithTools(messages, options), this.retryConfig)
+    );
+  }
+  async *stream(messages, options) {
+    yield* this.streamWithPolicy(() => this.provider.stream(messages, options));
+  }
+  async *streamWithTools(messages, options) {
+    yield* this.streamWithPolicy(() => this.provider.streamWithTools(messages, options));
+  }
+  countTokens(text) {
+    return this.provider.countTokens(text);
+  }
+  getContextWindow() {
+    return this.provider.getContextWindow();
+  }
+  async isAvailable() {
+    try {
+      return await this.breaker.execute(() => this.provider.isAvailable());
+    } catch (error) {
+      if (error instanceof CircuitOpenError) {
+        return false;
+      }
+      return false;
+    }
+  }
+  getCircuitState() {
+    return this.breaker.getState();
+  }
+  resetCircuit() {
+    this.breaker.reset();
+  }
+  async *streamWithPolicy(createStream) {
+    let attempt = 0;
+    while (attempt <= this.streamRetryConfig.maxRetries) {
+      if (this.breaker.isOpen()) {
+        throw new CircuitOpenError(this.id, 0);
+      }
+      let emittedChunk = false;
+      try {
+        for await (const chunk of createStream()) {
+          emittedChunk = true;
+          yield chunk;
+        }
+        this.breaker.recordSuccess();
+        return;
+      } catch (error) {
+        this.breaker.recordFailure();
+        const shouldRetry = !emittedChunk && attempt < this.streamRetryConfig.maxRetries && isRetryableError(error);
+        if (!shouldRetry) {
+          throw error;
+        }
+        const delay = computeRetryDelay(attempt, this.streamRetryConfig);
+        await sleep2(delay);
+        attempt++;
+      }
+    }
+  }
+};
+function getDefaultResilienceConfig(providerId) {
+  if (providerId === "ollama" || providerId === "lmstudio") {
+    return {
+      retry: {
+        maxRetries: 1,
+        initialDelayMs: 300,
+        maxDelayMs: 1500
+      },
+      streamRetry: {
+        maxRetries: 0
+      },
+      circuitBreaker: {
+        failureThreshold: 3,
+        resetTimeout: 1e4
+      }
+    };
+  }
+  return {
+    retry: {
+      maxRetries: 3,
+      initialDelayMs: 1e3,
+      maxDelayMs: 3e4
+    },
+    streamRetry: {
+      maxRetries: 1,
+      initialDelayMs: 500,
+      maxDelayMs: 5e3
+    },
+    circuitBreaker: {
+      failureThreshold: 5,
+      resetTimeout: 3e4
+    }
+  };
+}
+function createResilientProvider(provider, config) {
+  return new ResilientProvider(provider, getDefaultResilienceConfig(provider.id));
+}
+
 // src/providers/index.ts
 init_copilot();
 init_errors();
@@ -15546,12 +15944,10 @@ async function createProvider(type, config = {}) {
       break;
     case "kimi":
       provider = createKimiProvider(mergedConfig);
-      await provider.initialize(mergedConfig);
-      return provider;
+      break;
     case "kimi-code":
       provider = createKimiCodeProvider(mergedConfig);
-      await provider.initialize(mergedConfig);
-      return provider;
+      break;
     case "lmstudio":
       provider = new OpenAIProvider("lmstudio", "LM Studio");
       mergedConfig.baseUrl = mergedConfig.baseUrl ?? "http://localhost:1234/v1";
@@ -15596,7 +15992,10 @@ async function createProvider(type, config = {}) {
       });
   }
   await provider.initialize(mergedConfig);
-  return provider;
+  const resilienceEnabled = !["0", "false", "off"].includes(
+    (process.env["COCO_PROVIDER_RESILIENCE"] ?? "1").toLowerCase()
+  );
+  return resilienceEnabled ? createResilientProvider(provider) : provider;
 }
 
 // src/orchestrator/orchestrator.ts