@corbat-tech/coco 2.23.0 → 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,7 +1936,7 @@ var init_openai = __esm({
           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();
@@ -1805,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) {
@@ -1841,37 +1962,31 @@ var init_openai = __esm({
               }
               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
                     };
                   }
                 }
@@ -1880,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
                 }
               };
             }
@@ -2337,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)
                 });
               }
             }
@@ -2443,7 +2557,7 @@ var init_openai = __esm({
           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();
@@ -2467,57 +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: ""
+                  {
+                    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"
                     );
@@ -2637,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 {};
-        }
-      }
     };
   }
 });
@@ -4283,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;
@@ -4298,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) {
@@ -4327,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 = {
@@ -4639,7 +4732,7 @@ var init_codex = __esm({
           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) {
@@ -4650,31 +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: ""
-                  });
-                }
+                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;
               }
@@ -4685,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;
               }
             }
@@ -4786,7 +4882,7 @@ var init_codex = __esm({
         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(() => {
@@ -4819,55 +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: ""
-                    });
+                  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");
@@ -5243,8 +5342,8 @@ var init_gemini = __esm({
           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 text13 = chunk.text();
             if (text13) {
@@ -5259,30 +5358,23 @@ var init_gemini = __esm({
               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
+                  };
                 }
               }
             }
@@ -5357,13 +5449,13 @@ var init_gemini = __esm({
        * 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 = [];
@@ -5372,23 +5464,49 @@ var init_gemini = __esm({
                   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
        */
@@ -5465,14 +5583,15 @@ var init_gemini = __esm({
         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 ?? {}
               });
@@ -6068,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, {
@@ -6471,6 +6738,7 @@ __export(providers_exports, {
   MODEL_PRICING: () => MODEL_PRICING,
   OpenAIProvider: () => OpenAIProvider,
   ProviderFallback: () => ProviderFallback,
+  ResilientProvider: () => ResilientProvider,
   createAnthropicProvider: () => createAnthropicProvider,
   createCircuitBreaker: () => createCircuitBreaker,
   createCodexProvider: () => createCodexProvider,
@@ -6481,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,
@@ -6520,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";
@@ -6570,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));
@@ -6624,6 +6895,7 @@ var init_providers = __esm({
     init_pricing();
     init_circuit_breaker();
     init_fallback();
+    init_resilient();
     init_copilot();
     init_anthropic();
     init_openai();
@@ -6632,6 +6904,7 @@ var init_providers = __esm({
     init_copilot2();
     init_errors();
     init_env();
+    init_resilient();
   }
 });
 
@@ -9394,7 +9667,7 @@ async function checkAndCompactContext(session, provider, signal, toolRegistry) {
       session.contextManager.setUsedTokens(result.compactedTokens);
     }
     return result;
-  } catch (error) {
+  } catch {
     return null;
   }
 }
@@ -10498,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;
@@ -19048,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) {
@@ -19098,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({
@@ -19123,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({
@@ -31546,6 +31847,15 @@ async function selectModelInteractively(models, currentModelId) {
     renderMenu();
   });
 }
+async function persistModelPreference(provider, model) {
+  try {
+    await saveProviderPreference(provider, model);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.log(chalk2.yellow(`\u26A0 Could not persist model preference: ${reason}`));
+    console.log(chalk2.dim("  Model changed for this session only.\n"));
+  }
+}
 var modelCommand = {
   name: "model",
   aliases: ["m"],
@@ -31594,7 +31904,7 @@ var modelCommand = {
         return false;
       }
       session.config.provider.model = selectedModel;
-      await saveProviderPreference(currentProvider, selectedModel);
+      await persistModelPreference(currentProvider, selectedModel);
       const modelInfo2 = providerDef.models.find((m) => m.id === selectedModel);
       console.log(chalk2.green(`\u2713 Switched to ${modelInfo2?.name ?? selectedModel}
 `));
@@ -31616,7 +31926,7 @@ var modelCommand = {
     if (!foundInProvider) {
       console.log(chalk2.yellow(`Model "${newModel}" not in known list, setting anyway...`));
       session.config.provider.model = newModel;
-      await saveProviderPreference(currentProvider, newModel);
+      await persistModelPreference(currentProvider, newModel);
       console.log(chalk2.green(`\u2713 Model set to: ${newModel}
 `));
       return false;
@@ -31631,7 +31941,7 @@ var modelCommand = {
       return false;
     }
     session.config.provider.model = newModel;
-    await saveProviderPreference(currentProvider, newModel);
+    await persistModelPreference(currentProvider, newModel);
     const modelInfo = providerDef.models.find((m) => m.id === newModel);
     console.log(chalk2.green(`\u2713 Switched to ${modelInfo?.name ?? newModel}
 `));
@@ -50052,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;
@@ -50060,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"
@@ -50179,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}]`
@@ -50194,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
@@ -50399,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 {
@@ -50550,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
   };
 }