@corbat-tech/coco 2.23.1 → 2.24.0

package/dist/cli/index.js

@@ -1425,6 +1425,150 @@ var init_anthropic = __esm({
     };
   }
 });
+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, ResponsesToolCallAssembler;
+var init_tool_call_normalizer = __esm({
+  "src/providers/tool-call-normalizer.ts"() {
+    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 text13 = delta.function?.arguments ?? "";
+        if (!text13) return { started };
+        builder.arguments += text13;
+        return {
+          started,
+          argumentDelta: {
+            id: builder.id,
+            name: builder.name,
+            text: text13
+          }
+        };
+      }
+      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;
+      }
+    };
+    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);
+          }
+        }
+      }
+    };
+  }
+});
 function needsResponsesApi(model) {
   return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model === "o3";
 }
@@ -1464,6 +1608,7 @@ var init_openai = __esm({
   "src/providers/openai.ts"() {
     init_errors();
     init_retry();
+    init_tool_call_normalizer();
     DEFAULT_MODEL2 = "gpt-5.4-codex";
     CONTEXT_WINDOWS2 = {
       // OpenAI models
@@ -1791,8 +1936,7 @@ var init_openai = __esm({
           const stream = await this.client.chat.completions.create(
             requestParams
           );
-          const toolCallBuilders = /* @__PURE__ */ new Map();
-          let lastToolCallKey = null;
+          const toolCallAssembler = new ChatToolCallAssembler();
           const streamTimeout = this.config.timeout ?? 12e4;
           let lastActivityTime = Date.now();
           const timeoutController = new AbortController();
@@ -1806,30 +1950,6 @@ var init_openai = __esm({
           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) {
@@ -1842,38 +1962,31 @@ var init_openai = __esm({
               }
               if (delta?.tool_calls) {
                 for (const toolCallDelta of delta.tool_calls) {
-                  const key = typeof toolCallDelta.index === "number" ? `index:${toolCallDelta.index}` : typeof toolCallDelta.id === "string" && toolCallDelta.id.length > 0 ? `id:${toolCallDelta.id}` : toolCallBuilders.size === 1 ? Array.from(toolCallBuilders.keys())[0] ?? `fallback:${toolCallBuilders.size}` : lastToolCallKey ?? `fallback:${toolCallBuilders.size}`;
-                  if (!toolCallBuilders.has(key)) {
-                    toolCallBuilders.set(key, {
-                      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(key);
-                  lastToolCallKey = key;
-                  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
                     };
                   }
                 }
@@ -1882,27 +1995,26 @@ var init_openai = __esm({
               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
                 }
               };
             }
@@ -2339,7 +2451,7 @@ var init_openai = __esm({
                 toolCalls.push({
                   id: item.call_id,
                   name: item.name,
-                  input: this.parseResponsesArguments(item.arguments)
+                  input: parseToolCallArguments(item.arguments, this.name)
                 });
               }
             }
@@ -2445,8 +2557,7 @@ var init_openai = __esm({
           const stream = await this.client.responses.create(
             requestParams
           );
-          const fnCallBuilders = /* @__PURE__ */ new Map();
-          const outputIndexToBuilderKey = /* @__PURE__ */ new Map();
+          const toolCallAssembler = new ResponsesToolCallAssembler();
           const streamTimeout = this.config.timeout ?? 12e4;
           let lastActivityTime = Date.now();
           const timeoutController = new AbortController();
@@ -2470,67 +2581,66 @@ var init_openai = __esm({
                   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: fc.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 (typeof event.output_index === "number") {
-                      outputIndexToBuilderKey.set(event.output_index, itemKey);
-                    }
+                    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 builderKey = (event.item_id && fnCallBuilders.has(event.item_id) ? event.item_id : null) ?? (typeof event.output_index === "number" ? outputIndexToBuilderKey.get(event.output_index) ?? null : null) ?? (fnCallBuilders.size === 1 ? Array.from(fnCallBuilders.keys())[0] : null);
-                    if (!builderKey) break;
-                    const builder = fnCallBuilders.get(builderKey);
-                    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 builderKey = (event.item_id && fnCallBuilders.has(event.item_id) ? event.item_id : null) ?? (typeof event.output_index === "number" ? outputIndexToBuilderKey.get(event.output_index) ?? null : null) ?? (fnCallBuilders.size === 1 ? Array.from(fnCallBuilders.keys())[0] : null);
-                    if (!builderKey) break;
-                    const builder = fnCallBuilders.get(builderKey);
-                    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 ?? builder.arguments)
+                          id: toolCall.id,
+                          name: toolCall.name,
+                          input: toolCall.input
                         }
                       };
-                      fnCallBuilders.delete(builderKey);
-                      for (const [idx, key] of outputIndexToBuilderKey.entries()) {
-                        if (key === builderKey) outputIndexToBuilderKey.delete(idx);
-                      }
                     }
                   }
                   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"
                     );
@@ -2650,24 +2760,6 @@ var init_openai = __esm({
           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 {};
-        }
-      }
     };
   }
 });
@@ -4296,6 +4388,8 @@ var init_auth = __esm({
     init_gcloud();
   }
 });
+
+// src/providers/codex.ts
 function parseJwtClaims(token) {
   const parts = token.split(".");
   if (parts.length !== 3 || !parts[1]) return void 0;
@@ -4311,21 +4405,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 {};
-  }
-}
 function createCodexProvider(config) {
   const provider = new CodexProvider();
   if (config) {
@@ -4340,6 +4419,7 @@ var init_codex = __esm({
     init_errors();
     init_auth();
     init_retry();
+    init_tool_call_normalizer();
     CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
     DEFAULT_MODEL3 = "gpt-5.4-codex";
     CONTEXT_WINDOWS3 = {
@@ -4652,8 +4732,7 @@ var init_codex = __esm({
           let inputTokens = 0;
           let outputTokens = 0;
           const toolCalls = [];
-          const fnCallBuilders = /* @__PURE__ */ new Map();
-          const outputIndexToBuilderKey = /* @__PURE__ */ new Map();
+          const toolCallAssembler = new ResponsesToolCallAssembler();
           await this.readSSEStream(response, (event) => {
             if (event.id) responseId = event.id;
             switch (event.type) {
@@ -4664,41 +4743,35 @@ var init_codex = __esm({
                 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: item.arguments ?? ""
-                  });
-                  if (typeof event.output_index === "number") {
-                    outputIndexToBuilderKey.set(event.output_index, itemKey);
-                  }
-                }
+                toolCallAssembler.onOutputItemAdded({
+                  output_index: event.output_index,
+                  item: event.item
+                });
                 break;
               }
               case "response.function_call_arguments.delta": {
-                const builderKey = (event.item_id && fnCallBuilders.has(event.item_id) ? event.item_id : null) ?? (typeof event.output_index === "number" ? outputIndexToBuilderKey.get(event.output_index) ?? null : null) ?? (fnCallBuilders.size === 1 ? Array.from(fnCallBuilders.keys())[0] : null);
-                if (!builderKey) break;
-                const builder = fnCallBuilders.get(builderKey);
-                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 builderKey = (event.item_id && fnCallBuilders.has(event.item_id) ? event.item_id : null) ?? (typeof event.output_index === "number" ? outputIndexToBuilderKey.get(event.output_index) ?? null : null) ?? (fnCallBuilders.size === 1 ? Array.from(fnCallBuilders.keys())[0] : null);
-                if (!builderKey) break;
-                const builder = fnCallBuilders.get(builderKey);
-                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 ?? builder.arguments)
+                    id: toolCall.id,
+                    name: toolCall.name,
+                    input: toolCall.input
                   });
-                  fnCallBuilders.delete(builderKey);
-                  for (const [idx, key] of outputIndexToBuilderKey.entries()) {
-                    if (key === builderKey) outputIndexToBuilderKey.delete(idx);
-                  }
                 }
                 break;
               }
@@ -4709,14 +4782,13 @@ var init_codex = __esm({
                   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;
               }
             }
@@ -4810,8 +4882,7 @@ var init_codex = __esm({
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
-        const fnCallBuilders = /* @__PURE__ */ new Map();
-        const outputIndexToBuilderKey = /* @__PURE__ */ new Map();
+        const toolCallAssembler = new ResponsesToolCallAssembler();
         let lastActivityTime = Date.now();
         const timeoutController = new AbortController();
         const timeoutInterval = setInterval(() => {
@@ -4844,65 +4915,58 @@ var init_codex = __esm({
                   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: item.arguments ?? ""
-                    });
-                    if (typeof event.output_index === "number") {
-                      outputIndexToBuilderKey.set(event.output_index, itemKey);
-                    }
+                  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 builderKey = (event.item_id && fnCallBuilders.has(event.item_id) ? event.item_id : null) ?? (typeof event.output_index === "number" ? outputIndexToBuilderKey.get(event.output_index) ?? null : null) ?? (fnCallBuilders.size === 1 ? Array.from(fnCallBuilders.keys())[0] : null);
-                  if (!builderKey) break;
-                  const builder = fnCallBuilders.get(builderKey);
-                  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 builderKey = (event.item_id && fnCallBuilders.has(event.item_id) ? event.item_id : null) ?? (typeof event.output_index === "number" ? outputIndexToBuilderKey.get(event.output_index) ?? null : null) ?? (fnCallBuilders.size === 1 ? Array.from(fnCallBuilders.keys())[0] : null);
-                  if (!builderKey) break;
-                  const builder = fnCallBuilders.get(builderKey);
-                  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(builderKey);
-                    for (const [idx, key] of outputIndexToBuilderKey.entries()) {
-                      if (key === builderKey) outputIndexToBuilderKey.delete(idx);
-                    }
                   }
                   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");
@@ -6123,6 +6187,154 @@ var init_fallback = __esm({
   }
 });
 
+// src/providers/resilient.ts
+function sleep2(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, 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));
+}
+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, config ?? getDefaultResilienceConfig(provider.id));
+}
+var DEFAULT_STREAM_RETRY, ResilientProvider;
+var init_resilient = __esm({
+  "src/providers/resilient.ts"() {
+    init_retry();
+    init_circuit_breaker();
+    DEFAULT_STREAM_RETRY = {
+      maxRetries: 1,
+      initialDelayMs: 500,
+      maxDelayMs: 5e3,
+      backoffMultiplier: 2,
+      jitterFactor: 0.1
+    };
+    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(text13) {
+        return this.provider.countTokens(text13);
+      }
+      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++;
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/config/env.ts
 var env_exports = {};
 __export(env_exports, {
@@ -6526,6 +6738,7 @@ __export(providers_exports, {
   MODEL_PRICING: () => MODEL_PRICING,
   OpenAIProvider: () => OpenAIProvider,
   ProviderFallback: () => ProviderFallback,
+  ResilientProvider: () => ResilientProvider,
   createAnthropicProvider: () => createAnthropicProvider,
   createCircuitBreaker: () => createCircuitBreaker,
   createCodexProvider: () => createCodexProvider,
@@ -6536,10 +6749,12 @@ __export(providers_exports, {
   createOpenAIProvider: () => createOpenAIProvider,
   createProvider: () => createProvider,
   createProviderFallback: () => createProviderFallback,
+  createResilientProvider: () => createResilientProvider,
   createRetryableMethod: () => createRetryableMethod,
   estimateCost: () => estimateCost,
   formatCost: () => formatCost,
   getDefaultProvider: () => getDefaultProvider2,
+  getDefaultResilienceConfig: () => getDefaultResilienceConfig,
   getModelPricing: () => getModelPricing,
   hasKnownPricing: () => hasKnownPricing,
   isRetryableError: () => isRetryableError,
@@ -6575,12 +6790,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";
@@ -6625,7 +6838,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;
 }
 async function getDefaultProvider2(config = {}) {
   const { getDefaultProvider: getEnvProvider } = await Promise.resolve().then(() => (init_env(), env_exports));
@@ -6679,6 +6895,7 @@ var init_providers = __esm({
     init_pricing();
     init_circuit_breaker();
     init_fallback();
+    init_resilient();
     init_copilot();
     init_anthropic();
     init_openai();
@@ -6687,6 +6904,7 @@ var init_providers = __esm({
     init_copilot2();
     init_errors();
     init_env();
+    init_resilient();
   }
 });
 
@@ -9449,7 +9667,7 @@ async function checkAndCompactContext(session, provider, signal, toolRegistry) {
       session.contextManager.setUsedTokens(result.compactedTokens);
     }
     return result;
-  } catch (error) {
+  } catch {
     return null;
   }
 }
@@ -10553,6 +10771,34 @@ function isAbortError(error, signal) {
   if (error.message.endsWith("Request was aborted.")) return true;
   return false;
 }
+function classifyAgentLoopError(error, signal) {
+  if (isAbortError(error, signal)) {
+    return {
+      kind: "abort",
+      message: "Request was aborted.",
+      original: error
+    };
+  }
+  if (isNonRetryableProviderError(error)) {
+    return {
+      kind: "provider_non_retryable",
+      message: error instanceof Error ? error.message : String(error),
+      original: error
+    };
+  }
+  if (error instanceof ProviderError) {
+    return {
+      kind: "provider_retryable",
+      message: error.message,
+      original: error
+    };
+  }
+  return {
+    kind: "unexpected",
+    message: error instanceof Error ? error.message : String(error),
+    original: error
+  };
+}
 function isNonRetryableProviderError(error) {
   if (error instanceof ProviderError) {
     const code = error.statusCode;
@@ -19103,7 +19349,7 @@ async function runCIChecks(ctx) {
         cwd: ctx.cwd
       });
       if (result.checks.length === 0) {
-        await sleep2(pollMs);
+        await sleep3(pollMs);
         continue;
       }
       if (result.allPassed) {
@@ -19153,7 +19399,7 @@ async function runCIChecks(ctx) {
       spinner18.message(`CI: ${passed}/${result.checks.length} passed, ${pending} pending...`);
     } catch {
     }
-    await sleep2(pollMs);
+    await sleep3(pollMs);
   }
   spinner18.stop("CI check timeout");
   const action = await p26.select({
@@ -19178,7 +19424,7 @@ async function runCIChecks(ctx) {
     durationMs: performance.now() - start
   };
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 var init_ci_checks = __esm({
@@ -50116,6 +50362,60 @@ function extractDeniedPath(error) {
 // src/cli/repl/agent-loop.ts
 init_allow_path_prompt();
 init_error_resilience();
+
+// src/cli/repl/turn-quality.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function computeTurnQualityMetrics(input) {
+  const executedToolCalls = input.executedTools.length;
+  const successfulToolCalls = input.executedTools.filter((t) => t.result.success).length;
+  const failedToolCalls = executedToolCalls - successfulToolCalls;
+  let score = 100;
+  if (input.hadError) score -= 25;
+  if (executedToolCalls > 0) {
+    const failureRatio = failedToolCalls / executedToolCalls;
+    score -= Math.round(failureRatio * 35);
+  }
+  if (input.maxIterations > 0) {
+    const iterationRatio = input.iterationsUsed / input.maxIterations;
+    if (iterationRatio > 0.8) score -= 10;
+    if (iterationRatio >= 1) score -= 10;
+  }
+  score += Math.min(input.repeatedOutputsSuppressed * 2, 8);
+  return {
+    score: clamp(score, 0, 100),
+    iterationsUsed: input.iterationsUsed,
+    maxIterations: input.maxIterations,
+    executedToolCalls,
+    successfulToolCalls,
+    failedToolCalls,
+    hadError: input.hadError,
+    repeatedOutputsSuppressed: input.repeatedOutputsSuppressed
+  };
+}
+var RepeatedOutputSuppressor = class {
+  seen = /* @__PURE__ */ new Map();
+  transform(toolName, content) {
+    const fingerprint = this.fingerprint(toolName, content);
+    const count = this.seen.get(fingerprint) ?? 0;
+    this.seen.set(fingerprint, count + 1);
+    if (count === 0) {
+      return { content, suppressed: false };
+    }
+    return {
+      content: `[Repeated tool output suppressed: '${toolName}' produced the same output as before (occurrence ${count + 1}). If needed, re-run with different inputs.]`,
+      suppressed: true
+    };
+  }
+  fingerprint(toolName, content) {
+    const head = content.slice(0, 200);
+    const tail = content.slice(-200);
+    return `${toolName}|${content.length}|${head}|${tail}`;
+  }
+};
+
+// src/cli/repl/agent-loop.ts
 async function executeAgentTurn(session, userMessage, provider, toolRegistry, options = {}) {
   resetLineBuffer();
   const messageSnapshot = session.messages.length;
@@ -50124,12 +50424,23 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
   let finalContent = "";
+  let hadTurnError = false;
+  let repeatedOutputsSuppressed = 0;
+  const repeatedOutputSuppressor = new RepeatedOutputSuppressor();
+  const buildQualityMetrics = () => computeTurnQualityMetrics({
+    iterationsUsed: iteration,
+    maxIterations,
+    executedTools,
+    hadError: hadTurnError,
+    repeatedOutputsSuppressed
+  });
   const abortReturn = () => {
     session.messages.length = messageSnapshot;
     return {
       content: finalContent,
       toolCalls: executedTools,
       usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+      quality: buildQualityMetrics(),
       aborted: true,
       partialContent: finalContent || void 0,
       abortReason: "user_cancel"
@@ -50243,13 +50554,15 @@ ${tail}`;
         options.onThinkingEnd?.();
         thinkingEnded = true;
       }
-      if (isAbortError(streamError, options.signal)) {
+      const classification = classifyAgentLoopError(streamError, options.signal);
+      if (classification.kind === "abort") {
         return abortReturn();
       }
-      if (isNonRetryableProviderError(streamError)) {
-        throw streamError;
+      if (classification.kind === "provider_non_retryable") {
+        throw classification.original;
       }
-      const errorMsg = streamError instanceof Error ? streamError.message : String(streamError);
+      hadTurnError = true;
+      const errorMsg = classification.message;
       addMessage(session, {
         role: "assistant",
         content: `[Error during streaming: ${errorMsg}]`
@@ -50258,6 +50571,7 @@ ${tail}`;
         content: finalContent || `[Error: ${errorMsg}]`,
         toolCalls: executedTools,
         usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+        quality: buildQualityMetrics(),
         aborted: false,
         partialContent: finalContent || void 0,
         error: errorMsg
@@ -50463,10 +50777,15 @@ ${tail}`;
       }
       const executedCall = executedTools.find((e) => e.id === toolCall.id);
       if (executedCall) {
+        const truncatedOutput = truncateInlineResult(executedCall.result.output, toolCall.name);
+        const transformedOutput = repeatedOutputSuppressor.transform(toolCall.name, truncatedOutput);
+        if (transformedOutput.suppressed) {
+          repeatedOutputsSuppressed++;
+        }
         toolResults.push({
           type: "tool_result",
           tool_use_id: toolCall.id,
-          content: truncateInlineResult(executedCall.result.output, toolCall.name),
+          content: transformedOutput.content,
           is_error: !executedCall.result.success
         });
       } else {
@@ -50614,6 +50933,7 @@ I have reached the maximum iteration limit (${maxIterations}). The task may be i
     content: finalContent,
     toolCalls: executedTools,
     usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens },
+    quality: buildQualityMetrics(),
     aborted: false
   };
 }