@jeffusion/bungee-llms 3.3.0 → 3.3.1

package/dist/index.js

@@ -2678,8 +2678,9 @@ function mapOpenAIFinishReasonToAnthropic(finishReason) {
     case "length":
       return "max_tokens";
     case "content_filter":
-      return "stop_sequence";
+      return "end_turn";
     case "tool_calls":
+    case "function_call":
       return "tool_use";
     default:
       return "end_turn";
@@ -2853,7 +2854,11 @@ class AnthropicToGeminiConverter {
         if (block.type === "text" && block.text) {
           parts.push({ text: block.text });
         } else if (block.type === "thinking" && block.thinking) {
-          parts.push({ text: block.thinking, thought: true });
+          const thinkingPart = { text: block.thinking, thought: true };
+          if (block.thought_signature) {
+            thinkingPart.thoughtSignature = block.thought_signature;
+          }
+          parts.push(thinkingPart);
         } else if (block.type === "image" && block.source) {
           parts.push({
             inlineData: {
@@ -3057,10 +3062,14 @@ class AnthropicToGeminiConverter {
     for (const part of parts) {
       if (part.text) {
         if (part.thought) {
-          content.push({
+          const thinkingBlock = {
             type: "thinking",
             thinking: part.text
-          });
+          };
+          if (part.thoughtSignature) {
+            thinkingBlock.thought_signature = part.thoughtSignature;
+          }
+          content.push(thinkingBlock);
         } else {
           content.push({
             type: "text",
@@ -3137,6 +3146,10 @@ class AnthropicToGeminiConverter {
             name: part.functionCall.name,
             input: {}
           };
+          if (part.thoughtSignature) {
+            contentBlock.thought_signature = part.thoughtSignature;
+            ctx.streamState.set(`part_${partIdx}_sig`, part.thoughtSignature);
+          }
         } else if (part.thought !== undefined) {
           contentBlock = {
             type: "thinking",
@@ -3159,6 +3172,9 @@ class AnthropicToGeminiConverter {
         const argsStr = JSON.stringify(part.functionCall.args || {});
         const lastArgsLength = Number(ctx.streamState.get(argsKey) ?? 0);
         const currentArgsLength = argsStr.length;
+        if (part.thoughtSignature && !ctx.streamState.has(`part_${partIdx}_sig`)) {
+          ctx.streamState.set(`part_${partIdx}_sig`, part.thoughtSignature);
+        }
         if (currentArgsLength > lastArgsLength) {
           const argsDelta = argsStr.substring(lastArgsLength);
           events.push({
@@ -3175,6 +3191,9 @@ class AnthropicToGeminiConverter {
         const thinkingKey = `part_${partIdx}_thinking_length`;
         const lastLength = Number(ctx.streamState.get(thinkingKey) ?? 0);
         const currentLength = part.thought.length;
+        if (part.thoughtSignature && !ctx.streamState.has(`part_${partIdx}_sig`)) {
+          ctx.streamState.set(`part_${partIdx}_sig`, part.thoughtSignature);
+        }
         if (currentLength > lastLength) {
           const delta = part.thought.substring(lastLength);
           events.push({
@@ -3205,10 +3224,15 @@ class AnthropicToGeminiConverter {
         }
       }
       if (hasFinish) {
-        events.push({
+        const stopEvent = {
           type: "content_block_stop",
           index: partIdx
-        });
+        };
+        const sig = ctx.streamState.get(`part_${partIdx}_sig`);
+        if (sig) {
+          stopEvent.thought_signature = sig;
+        }
+        events.push(stopEvent);
       }
     }
     return events;
@@ -3230,18 +3254,6 @@ class AnthropicToOpenAIConverter {
   from = "anthropic";
   to = "openai";
   configuredApiMode;
-  protocolConversion = new OpenAIProtocolConversion;
-  runtime = new LLMSRuntime;
-  constructor() {
-    this.runtime.registerAdapter(new AnthropicAdapter, {
-      provider: "anthropic",
-      displayName: "Anthropic"
-    });
-    this.runtime.registerAdapter(new OpenAIAdapter, {
-      provider: "openai",
-      displayName: "OpenAI"
-    });
-  }
   setApiMode(mode) {
     if (typeof mode !== "string") {
       this.configuredApiMode = undefined;
@@ -3262,21 +3274,6 @@ class AnthropicToOpenAIConverter {
     const value = options;
     this.setApiMode(value.anthropicToOpenAIApiMode);
   }
-  parseIntegerOption(value) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return Math.trunc(value);
-    }
-    if (typeof value === "string" && value.trim().length > 0) {
-      const parsed = parseInt(value, 10);
-      if (Number.isFinite(parsed)) {
-        return parsed;
-      }
-    }
-    return;
-  }
-  resolveReasoningMaxCompletionTokens(maxTokens) {
-    return this.parseIntegerOption(maxTokens);
-  }
   resolveTargetApiMode() {
     if (this.configuredApiMode) {
       return this.configuredApiMode;
@@ -3301,26 +3298,6 @@ class AnthropicToOpenAIConverter {
     }
     if (ctx.url.pathname === "/v1/messages" || ctx.url.pathname === "/messages") {
       const targetApiMode = this.resolveTargetApiMode();
-      if (this.canUseRuntimeRequestConversion(body, targetApiMode)) {
-        ctx.url.pathname = "/v1/chat/completions";
-        let runtimeRequestBody;
-        try {
-          runtimeRequestBody = this.runtime.convertRequest("anthropic", "openai", body, { pathname: "/v1/chat/completions" });
-        } catch {
-          ctx.body = this.buildOpenAIRequest(body);
-          return;
-        }
-        if (!runtimeRequestBody || typeof runtimeRequestBody !== "object" || Array.isArray(runtimeRequestBody)) {
-          ctx.body = this.buildOpenAIRequest(body);
-          return;
-        }
-        const model = runtimeRequestBody.model;
-        if (typeof model !== "string" || model.trim().length === 0) {
-          runtimeRequestBody.model = "gpt-4";
-        }
-        ctx.body = runtimeRequestBody;
-        return;
-      }
       if (targetApiMode === "responses") {
         ctx.url.pathname = "/v1/responses";
         ctx.body = this.buildOpenAIResponsesRequest(body);
@@ -3330,43 +3307,6 @@ class AnthropicToOpenAIConverter {
       }
     }
   }
-  canUseRuntimeRequestConversion(anthropicBody, targetApiMode) {
-    if (targetApiMode !== "chat_completions") {
-      return false;
-    }
-    if (!anthropicBody || typeof anthropicBody !== "object" || Array.isArray(anthropicBody)) {
-      return false;
-    }
-    const body = anthropicBody;
-    if (typeof body.system !== "string" && body.system !== undefined) {
-      return false;
-    }
-    if (body.tools !== undefined || body.tool_choice !== undefined || body.thinking !== undefined || body.output_config !== undefined || body.top_k !== undefined) {
-      return false;
-    }
-    if (!Array.isArray(body.messages)) {
-      return false;
-    }
-    if (body.messages.length === 0) {
-      const hasNonEmptySystem = typeof body.system === "string" && body.system.trim().length > 0;
-      if (!hasNonEmptySystem) {
-        return false;
-      }
-    }
-    for (const message of body.messages) {
-      if (!message || typeof message !== "object" || Array.isArray(message)) {
-        return false;
-      }
-      const typedMessage = message;
-      if (typedMessage.role !== "user" && typedMessage.role !== "assistant") {
-        return false;
-      }
-      if (typeof typedMessage.content !== "string") {
-        return false;
-      }
-    }
-    return true;
-  }
   isAnthropicCountTokensPath(pathname) {
     return pathname === "/v1/messages/count_tokens" || pathname === "/messages/count_tokens" || pathname.endsWith("/messages/count_tokens");
   }
@@ -3387,10 +3327,12 @@ class AnthropicToOpenAIConverter {
   }
   buildOpenAIRequest(anthropicBody) {
     const openaiBody = {};
-    openaiBody.model = anthropicBody.model || "gpt-4";
+    if (typeof anthropicBody.model === "string") {
+      openaiBody.model = anthropicBody.model;
+    }
     const messages = [];
     messages.push(...this.convertSystemMessages(anthropicBody.system));
-    if (anthropicBody.messages) {
+    if (Array.isArray(anthropicBody.messages)) {
       for (const msg of anthropicBody.messages) {
         if (msg.role === "user") {
           this.convertUserMessage(msg, messages);
@@ -3399,13 +3341,18 @@ class AnthropicToOpenAIConverter {
         }
       }
     }
-    openaiBody.messages = this.validateAndCleanToolCalls(messages);
+    this.normalizeOpenAISystemMessages(messages);
+    openaiBody.messages = messages;
     if (!Array.isArray(openaiBody.messages) || openaiBody.messages.length === 0) {
       openaiBody.messages = [{ role: "user", content: "" }];
     }
-    const maxTokens = anthropicBody.max_tokens || anthropicBody.max_tokens_to_sample;
+    const maxTokens = anthropicBody.max_tokens ?? anthropicBody.max_tokens_to_sample;
     if (maxTokens !== undefined) {
-      openaiBody.max_tokens = maxTokens;
+      if (typeof openaiBody.model === "string" && this.isOpenAINumericOSeriesModel(openaiBody.model)) {
+        openaiBody.max_completion_tokens = maxTokens;
+      } else {
+        openaiBody.max_tokens = maxTokens;
+      }
     }
     if (anthropicBody.temperature !== undefined) {
       openaiBody.temperature = anthropicBody.temperature;
@@ -3414,156 +3361,289 @@ class AnthropicToOpenAIConverter {
       openaiBody.top_p = anthropicBody.top_p;
     }
     if (anthropicBody.stop_sequences !== undefined) {
-      openaiBody.stop = Array.isArray(anthropicBody.stop_sequences) ? anthropicBody.stop_sequences : [anthropicBody.stop_sequences];
+      openaiBody.stop = anthropicBody.stop_sequences;
     }
     if (anthropicBody.stream !== undefined) {
       openaiBody.stream = anthropicBody.stream;
     }
     if (Array.isArray(anthropicBody.tools)) {
-      openaiBody.tools = anthropicBody.tools.filter((tool) => typeof tool?.name === "string" && tool.name.trim().length > 0).map((tool) => ({
-        type: "function",
-        function: {
-          name: tool.name.trim(),
-          description: tool.description || "",
-          parameters: this.normalizeToolParametersSchema(tool.input_schema)
+      openaiBody.tools = anthropicBody.tools.filter((tool) => tool?.type !== "BatchTool").map((tool) => {
+        const mappedTool = {
+          type: "function",
+          function: {
+            name: typeof tool?.name === "string" ? tool.name : "",
+            description: tool?.description,
+            parameters: this.cleanOpenAIToolSchema(tool?.input_schema ?? {})
+          }
+        };
+        if (tool.cache_control !== undefined) {
+          mappedTool.cache_control = tool.cache_control;
         }
-      }));
+        return mappedTool;
+      });
       if (openaiBody.tools.length === 0) {
         delete openaiBody.tools;
       }
     }
-    const toolChoice = this.mapAnthropicToolChoiceToOpenAI(anthropicBody.tool_choice);
-    if (toolChoice !== undefined) {
-      openaiBody.tool_choice = toolChoice;
+    if (anthropicBody.tool_choice !== undefined) {
+      openaiBody.tool_choice = anthropicBody.tool_choice;
     }
-    const thinkingEnabled = this.isAnthropicThinkingEnabled(anthropicBody.thinking);
-    const thinkingEffort = this.resolveAnthropicThinkingEffort(anthropicBody.thinking);
-    const outputConfigEffort = this.resolveOutputConfigEffort(anthropicBody.output_config);
-    const shouldApplyReasoningFields = thinkingEnabled || thinkingEffort !== undefined || outputConfigEffort !== undefined;
-    if (shouldApplyReasoningFields) {
-      const effort = this.normalizeOpenAIReasoningEffort(thinkingEffort || outputConfigEffort, openaiBody.model);
-      if (effort) {
-        openaiBody.reasoning_effort = effort;
-      }
-      const maxCompletionTokens = this.resolveReasoningMaxCompletionTokens(openaiBody.max_tokens);
-      if (maxCompletionTokens !== undefined) {
-        openaiBody.max_completion_tokens = maxCompletionTokens;
-        delete openaiBody.max_tokens;
-      }
+    const promptCacheKey = this.resolvePromptCacheKey(anthropicBody);
+    if (promptCacheKey) {
+      openaiBody.prompt_cache_key = promptCacheKey;
+    }
+    const reasoningEffort = this.resolveAnthropicReasoningEffort(anthropicBody);
+    if (reasoningEffort && this.supportsReasoningEffort(openaiBody.model)) {
+      openaiBody.reasoning_effort = reasoningEffort;
     }
     return openaiBody;
   }
-  isAnthropicThinkingEnabled(thinking) {
-    if (!thinking || typeof thinking !== "object") {
-      return false;
-    }
-    const rawType = typeof thinking.type === "string" ? thinking.type.trim().toLowerCase() : "";
-    return rawType === "enabled" || rawType === "adaptive";
+  isOpenAINumericOSeriesModel(model) {
+    const normalized = model.trim().toLowerCase();
+    return normalized.length > 1 && normalized[0] === "o" && /\d/.test(normalized[1]);
   }
-  resolveAnthropicThinkingEffort(thinking) {
-    if (!thinking || typeof thinking !== "object") {
-      return;
+  buildOpenAIResponsesRequest(anthropicBody) {
+    const responsesBody = {};
+    if (typeof anthropicBody.model === "string") {
+      responsesBody.model = anthropicBody.model;
+    }
+    const instructions = this.convertAnthropicSystemToInstructions(anthropicBody.system);
+    if (instructions) {
+      responsesBody.instructions = instructions;
     }
-    const rawEffort = typeof thinking.effort === "string" ? thinking.effort.trim().toLowerCase() : "";
-    if (rawEffort === "low" || rawEffort === "medium" || rawEffort === "high") {
-      return rawEffort;
+    const input = this.convertAnthropicMessagesToResponsesInput(anthropicBody.messages);
+    if (input.length > 0) {
+      responsesBody.input = input;
     }
-    if (rawEffort === "max") {
-      return "xhigh";
+    const maxTokens = anthropicBody.max_tokens ?? anthropicBody.max_tokens_to_sample;
+    if (maxTokens !== undefined) {
+      responsesBody.max_output_tokens = maxTokens;
     }
-    if (rawEffort === "min") {
-      return "low";
+    if (anthropicBody.temperature !== undefined) {
+      responsesBody.temperature = anthropicBody.temperature;
     }
-    return;
-  }
-  resolveOutputConfigEffort(outputConfig) {
-    if (!outputConfig || typeof outputConfig !== "object") {
-      return;
+    if (anthropicBody.top_p !== undefined) {
+      responsesBody.top_p = anthropicBody.top_p;
     }
-    const rawEffort = typeof outputConfig.effort === "string" ? outputConfig.effort.trim().toLowerCase() : "";
-    if (rawEffort === "low" || rawEffort === "medium" || rawEffort === "high") {
-      return rawEffort;
+    if (anthropicBody.stream !== undefined) {
+      responsesBody.stream = anthropicBody.stream;
     }
-    if (rawEffort === "max") {
-      return "xhigh";
+    if (Array.isArray(anthropicBody.tools)) {
+      const tools = anthropicBody.tools.filter((tool) => tool?.type !== "BatchTool").map((tool) => ({
+        type: "function",
+        name: tool.name || "",
+        description: tool.description,
+        parameters: this.normalizeToolParametersSchema(tool.input_schema)
+      }));
+      if (tools.length > 0) {
+        responsesBody.tools = tools;
+      }
     }
-    if (rawEffort === "min") {
-      return "low";
+    const toolChoice = this.mapAnthropicToolChoiceToResponses(anthropicBody.tool_choice);
+    if (toolChoice !== undefined) {
+      responsesBody.tool_choice = toolChoice;
     }
-    return;
-  }
-  normalizeOpenAIReasoningEffort(effort, model) {
-    if (!effort) {
-      return;
+    const reasoningEffort = this.resolveAnthropicReasoningEffort(anthropicBody);
+    if (reasoningEffort && this.supportsReasoningEffort(responsesBody.model)) {
+      responsesBody.reasoning = {
+        effort: reasoningEffort
+      };
     }
-    if (effort !== "xhigh") {
-      return effort;
+    const promptCacheKey = this.resolvePromptCacheKey(anthropicBody);
+    if (promptCacheKey) {
+      responsesBody.prompt_cache_key = promptCacheKey;
     }
-    return this.supportsXHighReasoningEffort(model) ? "xhigh" : "high";
+    return responsesBody;
   }
-  supportsXHighReasoningEffort(model) {
-    const normalized = typeof model === "string" ? model.trim().toLowerCase() : "";
-    if (!normalized) {
-      return false;
+  convertAnthropicSystemToInstructions(system) {
+    if (typeof system === "string") {
+      const cleaned = this.sanitizeSystemText(system).trim();
+      return cleaned || undefined;
     }
-    if (normalized.includes("gpt-5-pro")) {
-      return false;
+    if (!Array.isArray(system)) {
+      return;
     }
-    if (normalized.includes("codex-max")) {
-      return true;
+    const texts = [];
+    for (const block of system) {
+      if (typeof block === "string") {
+        const cleaned = this.sanitizeSystemText(block).trim();
+        if (cleaned)
+          texts.push(cleaned);
+      } else if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+        const cleaned = this.sanitizeSystemText(block.text).trim();
+        if (cleaned)
+          texts.push(cleaned);
+      }
     }
-    const gpt5MinorMatch = normalized.match(/gpt-5\.(\d+)/);
-    if (gpt5MinorMatch) {
-      const minor = parseInt(gpt5MinorMatch[1], 10);
-      if (Number.isFinite(minor)) {
-        return minor >= 2;
+    return texts.length > 0 ? texts.join(`
+
+`) : undefined;
+  }
+  convertAnthropicMessagesToResponsesInput(messages) {
+    const input = [];
+    if (!Array.isArray(messages)) {
+      return input;
+    }
+    for (const msg of messages) {
+      if (!msg || typeof msg !== "object")
+        continue;
+      const role = msg.role === "assistant" ? "assistant" : "user";
+      const content = msg.content;
+      if (typeof content === "string") {
+        input.push({
+          role,
+          content: [{ type: role === "assistant" ? "output_text" : "input_text", text: content }]
+        });
+        continue;
+      }
+      if (Array.isArray(content)) {
+        let contentItems = [];
+        const flushContentItems = () => {
+          if (contentItems.length > 0) {
+            input.push({ role, content: contentItems });
+            contentItems = [];
+          }
+        };
+        for (const block of content) {
+          if (!block || typeof block !== "object")
+            continue;
+          switch (block.type) {
+            case "text":
+              if (typeof block.text === "string") {
+                contentItems.push({
+                  type: role === "assistant" ? "output_text" : "input_text",
+                  text: block.text
+                });
+              }
+              break;
+            case "image":
+              if (role !== "assistant" && block.source) {
+                const imageUrl = this.convertAnthropicImageSourceToUrl(block.source);
+                if (imageUrl) {
+                  contentItems.push({ type: "input_image", image_url: imageUrl });
+                }
+              }
+              break;
+            case "tool_use":
+              flushContentItems();
+              input.push({
+                type: "function_call",
+                call_id: block.id || "",
+                name: block.name || "",
+                arguments: typeof block.input === "object" ? JSON.stringify(block.input) : "{}"
+              });
+              break;
+            case "tool_result":
+              flushContentItems();
+              input.push({
+                type: "function_call_output",
+                call_id: block.tool_use_id || "",
+                output: this.normalizeToolResultContent(block.content)
+              });
+              break;
+            case "thinking":
+              break;
+          }
+        }
+        flushContentItems();
+        continue;
       }
+      input.push({ role });
     }
-    return false;
+    return input;
   }
-  buildOpenAIResponsesRequest(anthropicBody) {
-    const chatBody = this.buildOpenAIRequest(anthropicBody);
-    const responsesInput = this.protocolConversion.convertChatMessagesToResponsesInput(chatBody.messages);
-    const responsesBody = {
-      model: chatBody.model,
-      input: responsesInput.input
-    };
-    if (responsesInput.instructions) {
-      responsesBody.instructions = responsesInput.instructions;
+  convertAnthropicImageSourceToUrl(source) {
+    if (!source || typeof source !== "object")
+      return null;
+    if (source.type === "base64" && source.media_type && source.data) {
+      return `data:${source.media_type};base64,${source.data}`;
     }
-    const maxOutputTokens = chatBody.max_tokens ?? chatBody.max_completion_tokens;
-    if (maxOutputTokens !== undefined) {
-      responsesBody.max_output_tokens = maxOutputTokens;
+    return null;
+  }
+  mapAnthropicToolChoiceToResponses(toolChoice) {
+    if (toolChoice === undefined || toolChoice === null) {
+      return;
     }
-    if (chatBody.temperature !== undefined) {
-      responsesBody.temperature = chatBody.temperature;
+    if (typeof toolChoice === "string") {
+      return toolChoice;
     }
-    if (chatBody.top_p !== undefined) {
-      responsesBody.top_p = chatBody.top_p;
+    if (typeof toolChoice !== "object" || Array.isArray(toolChoice)) {
+      return;
     }
-    if (chatBody.tools !== undefined) {
-      const mappedTools = this.protocolConversion.mapChatToolsToResponsesTools(chatBody.tools);
-      if (mappedTools.length > 0) {
-        responsesBody.tools = mappedTools;
-      }
+    const choice = toolChoice;
+    const type = typeof choice.type === "string" ? choice.type.trim().toLowerCase() : "";
+    if (type === "any") {
+      return "required";
     }
-    if (chatBody.stop !== undefined) {
-      responsesBody.stop = chatBody.stop;
+    if (type === "auto") {
+      return "auto";
     }
-    if (chatBody.reasoning_effort !== undefined) {
-      responsesBody.reasoning = {
-        effort: chatBody.reasoning_effort,
-        summary: "auto"
+    if (type === "none") {
+      return "none";
+    }
+    if (type === "tool") {
+      return {
+        type: "function",
+        name: typeof choice.name === "string" ? choice.name : ""
       };
     }
-    if (chatBody.stream === true) {
-      responsesBody.stream = true;
+    return toolChoice;
+  }
+  resolveAnthropicReasoningEffort(anthropicBody) {
+    if (anthropicBody.output_config && typeof anthropicBody.output_config === "object") {
+      const effort = typeof anthropicBody.output_config.effort === "string" ? anthropicBody.output_config.effort.trim().toLowerCase() : "";
+      if (effort === "low" || effort === "medium" || effort === "high") {
+        return effort;
+      }
+      if (effort === "max") {
+        return "xhigh";
+      }
     }
-    return responsesBody;
+    if (anthropicBody.thinking && typeof anthropicBody.thinking === "object") {
+      const thinkingType = typeof anthropicBody.thinking.type === "string" ? anthropicBody.thinking.type.trim().toLowerCase() : "";
+      const thinkingEffort = typeof anthropicBody.thinking.effort === "string" ? anthropicBody.thinking.effort.trim().toLowerCase() : "";
+      if (thinkingEffort === "low" || thinkingEffort === "medium" || thinkingEffort === "high") {
+        return thinkingEffort;
+      }
+      if (thinkingEffort === "max") {
+        return "xhigh";
+      }
+      if (thinkingType === "adaptive") {
+        return "xhigh";
+      }
+      if (thinkingType === "enabled") {
+        const budgetTokens = anthropicBody.thinking.budget_tokens;
+        if (typeof budgetTokens === "number") {
+          if (budgetTokens < 4000)
+            return "low";
+          if (budgetTokens < 16000)
+            return "medium";
+        }
+        return "high";
+      }
+    }
+    return;
+  }
+  supportsReasoningEffort(model) {
+    if (!model || typeof model !== "string") {
+      return false;
+    }
+    const normalized = model.trim().toLowerCase();
+    if (normalized.length > 1 && normalized[0] === "o" && /\d/.test(normalized[1])) {
+      return true;
+    }
+    if (normalized.startsWith("gpt-")) {
+      const match = normalized.match(/gpt-(\d+)/);
+      if (match) {
+        const version = parseInt(match[1], 10);
+        return version >= 5;
+      }
+    }
+    return false;
   }
   convertSystemMessages(system) {
     if (typeof system === "string") {
-      const content = system.trim();
+      const content = this.sanitizeSystemText(system).trim();
       return content ? [{ role: "system", content }] : [];
     }
     if (!Array.isArray(system)) {
@@ -3572,45 +3652,64 @@ class AnthropicToOpenAIConverter {
     const results = [];
     for (const block of system) {
       if (typeof block === "string") {
-        const content = block.trim();
+        const content = this.sanitizeSystemText(block).trim();
         if (content) {
           results.push({ role: "system", content });
         }
         continue;
       }
       if (block && typeof block === "object" && block.type === "text") {
-        const content = typeof block.text === "string" ? block.text.trim() : "";
+        const content = typeof block.text === "string" ? this.sanitizeSystemText(block.text).trim() : "";
         if (content) {
-          results.push({ role: "system", content });
+          const message = { role: "system", content };
+          if (block.cache_control !== undefined) {
+            message.cache_control = block.cache_control;
+          }
+          results.push(message);
         }
       }
     }
     return results;
   }
-  validateAndCleanToolCalls(messages) {
-    const toolResultIds = new Set(messages.filter((msg) => msg.role === "tool" && typeof msg.tool_call_id === "string" && msg.tool_call_id).map((msg) => msg.tool_call_id));
-    const cleanedMessages = [];
-    for (const msg of messages) {
-      if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) {
-        cleanedMessages.push(msg);
-        continue;
-      }
-      const matchedToolCalls = msg.tool_calls.filter((tc) => typeof tc?.id === "string" && toolResultIds.has(tc.id));
-      const hasTextContent = typeof msg.content === "string" && msg.content.trim().length > 0;
-      if (matchedToolCalls.length > 0) {
-        cleanedMessages.push({
-          ...msg,
-          tool_calls: matchedToolCalls,
-          content: hasTextContent ? msg.content : null
-        });
-        continue;
+  sanitizeSystemText(text) {
+    return text.split(/(?<=\n)/).filter((segment) => !segment.replace(/\n$/, "").trimStart().startsWith("x-anthropic-billing-header:")).join("");
+  }
+  extractTextFromOpenAIContent(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (!Array.isArray(content)) {
+      return "";
+    }
+    return content.map((part) => part?.type === "text" && typeof part.text === "string" ? part.text : "").filter((text) => text.length > 0).join(`
+`);
+  }
+  normalizeOpenAISystemMessages(messages) {
+    const systemMessages = messages.filter((message) => message?.role === "system");
+    if (systemMessages.length === 0) {
+      return;
+    }
+    if (systemMessages.length === 1) {
+      const index = messages.indexOf(systemMessages[0]);
+      if (index > 0) {
+        messages.splice(index, 1);
+        messages.unshift(systemMessages[0]);
       }
-      if (hasTextContent) {
-        const { tool_calls, ...assistantTextOnly } = msg;
-        cleanedMessages.push(assistantTextOnly);
+      return;
+    }
+    const combinedContent = systemMessages.map((message) => this.extractTextFromOpenAIContent(message.content)).filter((text) => text.length > 0).join(`
+`);
+    for (let index = messages.length - 1;index >= 0; index -= 1) {
+      if (messages[index]?.role === "system") {
+        messages.splice(index, 1);
       }
     }
-    return cleanedMessages;
+    if (combinedContent) {
+      messages.unshift({
+        role: "system",
+        content: combinedContent
+      });
+    }
   }
   normalizeToolResultContent(content) {
     if (content === undefined || content === null) {
@@ -3619,59 +3718,16 @@ class AnthropicToOpenAIConverter {
     if (typeof content === "string") {
       return content;
     }
-    if (Array.isArray(content)) {
-      const normalizedBlocks = content.map((part) => {
-        if (typeof part === "string") {
-          return { type: "text", text: part };
-        }
-        if (!part || typeof part !== "object") {
-          return null;
-        }
-        if (part.type === "text" && typeof part.text === "string") {
-          return { type: "text", text: part.text };
-        }
-        if (part.type === "image" && part.source) {
-          if (part.source.type === "url" && typeof part.source.url === "string") {
-            return {
-              type: "image_url",
-              image_url: {
-                url: part.source.url
-              }
-            };
-          }
-          if (part.source.type === "base64" && part.source.media_type && part.source.data) {
-            return {
-              type: "image_url",
-              image_url: {
-                url: `data:${part.source.media_type};base64,${part.source.data}`
-              }
-            };
-          }
-        }
-        return {
-          type: "text",
-          text: JSON.stringify(part)
-        };
-      }).filter((block) => block !== null);
-      if (normalizedBlocks.length === 0) {
-        return "";
-      }
-      const firstBlock = normalizedBlocks[0];
-      if (normalizedBlocks.length === 1 && firstBlock && firstBlock.type === "text") {
-        return typeof firstBlock.text === "string" ? firstBlock.text : "";
-      }
-      return JSON.stringify(normalizedBlocks);
-    }
-    if (typeof content === "object") {
-      if ("content" in content) {
-        return this.normalizeToolResultContent(content.content);
-      }
+    if (typeof content === "object")
       return JSON.stringify(content);
-    }
     return String(content);
   }
   convertUserMessage(msg, messages) {
     const content = msg.content;
+    if (content === undefined) {
+      messages.push({ role: "user", content: null });
+      return;
+    }
     if (typeof content === "string") {
       messages.push({
         role: "user",
@@ -3683,8 +3739,8 @@ class AnthropicToOpenAIConverter {
       const hasToolResult = content.some((block) => block?.type === "tool_result");
       if (hasToolResult) {
         for (const block of content) {
-          const toolUseId = typeof block?.tool_use_id === "string" ? block.tool_use_id.trim() : "";
-          if (block?.type !== "tool_result" || toolUseId.length === 0) {
+          const toolUseId = typeof block?.tool_use_id === "string" ? block.tool_use_id : "";
+          if (block?.type !== "tool_result") {
             continue;
           }
           messages.push({
@@ -3698,39 +3754,43 @@ class AnthropicToOpenAIConverter {
       if (userContentBlocks.length > 0) {
         messages.push({
           role: "user",
-          content: userContentBlocks
+          content: this.normalizeOpenAIMessageContent(userContentBlocks)
         });
       }
+      return;
     }
+    messages.push({ role: "user", content });
   }
   convertUserContentBlock(block) {
     if (!block || typeof block !== "object") {
       return null;
     }
     if (block.type === "text") {
-      return {
+      const textBlock = {
         type: "text",
         text: block.text || ""
       };
+      if (block.cache_control !== undefined) {
+        textBlock.cache_control = block.cache_control;
+      }
+      return textBlock;
     }
     if (block.type === "image" && block.source) {
-      if (block.source.type === "url" && block.source.url) {
-        return {
-          type: "image_url",
-          image_url: { url: block.source.url }
-        };
-      }
-      if (block.source.type === "base64" && block.source.media_type && block.source.data) {
-        return {
-          type: "image_url",
-          image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
-        };
-      }
+      const mediaType = typeof block.source.media_type === "string" ? block.source.media_type : "image/png";
+      const data = typeof block.source.data === "string" ? block.source.data : "";
+      return {
+        type: "image_url",
+        image_url: { url: `data:${mediaType};base64,${data}` }
+      };
     }
     return null;
   }
   convertAssistantMessage(msg, messages) {
     const content = msg.content;
+    if (content === undefined) {
+      messages.push({ role: "assistant", content: null });
+      return;
+    }
     if (typeof content === "string") {
       messages.push({
         role: "assistant",
@@ -3739,122 +3799,49 @@ class AnthropicToOpenAIConverter {
       return;
     }
     if (Array.isArray(content)) {
-      const toolUseBlocks = content.filter((block) => block.type === "tool_use");
-      if (toolUseBlocks.length > 0) {
-        const validToolUseBlocks = toolUseBlocks.filter((block) => typeof block?.name === "string" && block.name.trim().length > 0);
-        const toolCalls = validToolUseBlocks.map((block, index) => ({
-          id: this.normalizeToolCallId(block.id, block.name, index),
-          type: "function",
-          function: {
-            name: String(block.name).trim(),
-            arguments: JSON.stringify(block.input || {})
-          }
-        }));
-        let textContent = "";
-        for (const block of content) {
-          if (block.type === "text") {
-            textContent += block.text || "";
-          } else if (block.type === "thinking") {
-            textContent += `<thinking>
-${block.thinking || ""}
-</thinking>
-
-`;
+      const contentParts = [];
+      const toolCalls = [];
+      for (const block of content) {
+        if (!block || typeof block !== "object")
+          continue;
+        if (block.type === "text" && typeof block.text === "string") {
+          const textBlock = { type: "text", text: block.text };
+          if (block.cache_control !== undefined) {
+            textBlock.cache_control = block.cache_control;
           }
+          contentParts.push(textBlock);
+          continue;
         }
-        if (toolCalls.length > 0 || textContent.trim()) {
-          messages.push({
-            role: "assistant",
-            content: textContent.trim() || null,
-            ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        if (block.type === "tool_use") {
+          toolCalls.push({
+            id: typeof block.id === "string" ? block.id : "",
+            type: "function",
+            function: {
+              name: typeof block.name === "string" ? block.name : "",
+              arguments: JSON.stringify(block.input ?? {})
+            }
           });
         }
-      } else {
-        let textContent = "";
-        for (const block of content) {
-          if (block.type === "text") {
-            textContent += block.text || "";
-          } else if (block.type === "thinking") {
-            textContent += `<thinking>
-${block.thinking || ""}
-</thinking>
-
-`;
-          }
-        }
+      }
+      if (contentParts.length > 0 || toolCalls.length > 0) {
         messages.push({
           role: "assistant",
-          content: textContent.trim()
+          content: contentParts.length > 0 ? this.normalizeOpenAIMessageContent(contentParts) : null,
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
         });
       }
-    }
-  }
-  normalizeToolCallId(rawId, name, index) {
-    if (typeof rawId === "string" && rawId.trim()) {
-      return rawId.trim();
-    }
-    const normalizedName = typeof name === "string" && name.trim() ? name.trim() : "tool";
-    return `call_${normalizedName}_${index}`;
-  }
-  mapAnthropicToolChoiceToOpenAI(toolChoice) {
-    if (toolChoice === undefined || toolChoice === null) {
-      return;
-    }
-    if (typeof toolChoice === "string") {
-      const normalized = toolChoice.trim().toLowerCase();
-      if (normalized === "auto" || normalized === "none" || normalized === "required") {
-        return normalized;
-      }
-      if (normalized === "any") {
-        return "required";
-      }
-      return;
-    }
-    if (typeof toolChoice !== "object" || Array.isArray(toolChoice)) {
       return;
     }
-    const choice = toolChoice;
-    const type = typeof choice.type === "string" ? choice.type.trim().toLowerCase() : "";
-    if (type === "tool") {
-      const toolName = typeof choice.name === "string" ? choice.name.trim() : "";
-      if (!toolName) {
-        return;
-      }
-      return {
-        type: "function",
-        function: {
-          name: toolName
-        }
-      };
-    }
-    if (type === "any") {
-      return "required";
-    }
-    if (type === "auto" || type === "none") {
-      return type;
-    }
-    return;
+    messages.push({ role: "assistant", content });
   }
-  parseOpenAIImageUrlSource(url) {
-    if (!url)
-      return null;
-    if (url.startsWith("data:")) {
-      const parts = url.split(";base64,");
-      if (parts.length !== 2)
-        return null;
-      return {
-        type: "base64",
-        media_type: parts[0].replace("data:", ""),
-        data: parts[1]
-      };
-    }
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      return {
-        type: "url",
-        url
-      };
+  normalizeOpenAIMessageContent(contentParts) {
+    if (contentParts.length === 1) {
+      const first = contentParts[0];
+      if (first?.type === "text" && first.cache_control === undefined) {
+        return first.text;
+      }
     }
-    return null;
+    return contentParts;
   }
   normalizeToolParametersSchema(schema) {
     if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
@@ -3868,7 +3855,24 @@ ${block.thinking || ""}
         normalized.properties = {};
       }
     }
-    return normalized;
+    return normalized;
+  }
+  cleanOpenAIToolSchema(schema) {
+    return this.normalizeJsonSchema(schema);
+  }
+  resolvePromptCacheKey(anthropicBody) {
+    const candidates = [
+      anthropicBody?.prompt_cache_key,
+      anthropicBody?.metadata?.prompt_cache_key,
+      anthropicBody?.metadata?.provider_id,
+      anthropicBody?.metadata?.providerId
+    ];
+    for (const candidate of candidates) {
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
+    }
+    return;
   }
   normalizeJsonSchema(schema) {
     if (!schema || typeof schema !== "object") {
@@ -3879,6 +3883,9 @@ ${block.thinking || ""}
     }
     const result = {};
     for (const [key, value] of Object.entries(schema)) {
+      if (key === "format" && value === "uri") {
+        continue;
+      }
       if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
         const normalizedProperties = {};
         for (const [propName, propSchema] of Object.entries(value)) {
@@ -3944,6 +3951,14 @@ ${block.thinking || ""}
         headers: ctx.response.headers
       });
     }
+    if (this.isLikelyOpenAIErrorBody(openaiBody) && !this.isLikelyOpenAISuccessBody(openaiBody)) {
+      const anthropicError = this.convertOpenAIErrorToAnthropic(openaiBody, ctx.response.status);
+      return new Response(JSON.stringify(anthropicError), {
+        status: ctx.response.status,
+        statusText: ctx.response.statusText,
+        headers: ctx.response.headers
+      });
+    }
     if (!this.isLikelyOpenAISuccessBody(openaiBody)) {
       return ctx.response;
     }
@@ -3970,11 +3985,12 @@ ${block.thinking || ""}
     return 0;
   }
   convertOpenAIErrorToAnthropic(openaiBody, status) {
-    const message = typeof openaiBody?.error?.message === "string" && openaiBody.error.message || typeof openaiBody?.message === "string" && openaiBody.message || `OpenAI request failed with status ${status}`;
+    const message = typeof openaiBody?.error?.message === "string" && openaiBody.error.message || typeof openaiBody?.message === "string" && openaiBody.message || "Upstream error";
+    const type = typeof openaiBody?.error?.type === "string" && openaiBody.error.type.length > 0 ? openaiBody.error.type : "invalid_request_error";
     return {
       type: "error",
       error: {
-        type: "api_error",
+        type,
         message
       }
     };
@@ -4065,68 +4081,11 @@ ${block.thinking || ""}
     }
     return texts;
   }
-  appendUniqueThinkingBlocks(content, texts, seen) {
-    for (const text of texts) {
-      if (typeof text !== "string")
-        continue;
-      const normalized = text.trim();
-      if (!normalized)
-        continue;
-      if (seen.has(normalized))
-        continue;
-      content.push({
-        type: "thinking",
-        thinking: normalized
-      });
-      seen.add(normalized);
-    }
-  }
-  appendParsedContent(content, parsedContent, seenThinking) {
-    for (const block of parsedContent) {
-      if (!block || typeof block !== "object")
-        continue;
-      if (block.type === "thinking") {
-        const thinkingText = typeof block.thinking === "string" ? block.thinking.trim() : "";
-        if (!thinkingText || seenThinking.has(thinkingText)) {
-          continue;
-        }
-        content.push({
-          type: "thinking",
-          thinking: thinkingText
-        });
-        seenThinking.add(thinkingText);
-        continue;
-      }
-      if (block.type === "text") {
-        const text = typeof block.text === "string" ? block.text : "";
-        if (!text)
-          continue;
-        content.push({
-          type: "text",
-          text
-        });
-      }
-    }
-  }
-  extractChatCompletionReasoningTexts(message) {
-    const texts = [];
-    if (!message || typeof message !== "object") {
-      return texts;
-    }
-    const directReasoning = this.extractReasoningSummaryTexts({
-      summary: message.reasoning,
-      text: message.reasoning_content
-    });
-    texts.push(...directReasoning);
-    if (typeof message.reasoning === "string") {
-      texts.push(message.reasoning);
-    }
-    if (Array.isArray(message.reasoning_details)) {
-      for (const detail of message.reasoning_details) {
-        texts.push(...this.extractReasoningSummaryTexts(detail));
-      }
+  extractStrictResponsesReasoningText(reasoningItem) {
+    if (!reasoningItem || typeof reasoningItem !== "object" || !Array.isArray(reasoningItem.summary)) {
+      return "";
     }
-    return texts;
+    return reasoningItem.summary.filter((item) => item?.type === "summary_text" && typeof item.text === "string").map((item) => item.text).join("");
   }
   extractReasoningTextFromDeltaContentPart(part) {
     if (!part || typeof part !== "object") {
@@ -4230,6 +4189,19 @@ ${block.thinking || ""}
     ctx.streamState.set("chat_thinking_index", index);
     return index;
   }
+  closeChatNonToolBlock(events, ctx) {
+    const textIndex = ctx.streamState.get("chat_text_index");
+    if (typeof textIndex === "number" && Number.isFinite(textIndex)) {
+      events.push({ type: "content_block_stop", index: textIndex });
+      ctx.streamState.delete("chat_text_index");
+      ctx.streamState.delete("text_block_started");
+    }
+    const thinkingIndex = ctx.streamState.get("chat_thinking_index");
+    if (typeof thinkingIndex === "number" && Number.isFinite(thinkingIndex)) {
+      events.push({ type: "content_block_stop", index: thinkingIndex });
+      ctx.streamState.delete("chat_thinking_index");
+    }
+  }
   resolveChatToolIndex(rawIndex, ctx) {
     const normalizedRawIndex = Number.isFinite(rawIndex) ? Math.trunc(rawIndex) : 0;
     const mapKey = `chat_tool_index_${normalizedRawIndex}`;
@@ -4255,6 +4227,59 @@ ${block.thinking || ""}
     }
     return 1;
   }
+  nextResponsesContentIndex(ctx) {
+    const current = ctx.streamState.get("resp_next_content_index");
+    const next = typeof current === "number" && Number.isFinite(current) ? current : 0;
+    ctx.streamState.set("resp_next_content_index", next + 1);
+    return next;
+  }
+  resolveResponsesContentIndex(chunk, ctx) {
+    const itemId = typeof chunk?.item_id === "string" ? chunk.item_id : "";
+    const contentIndex = typeof chunk?.content_index === "number" ? chunk.content_index : undefined;
+    const outputIndex = typeof chunk?.output_index === "number" ? chunk.output_index : undefined;
+    const key = itemId && contentIndex !== undefined ? `resp_part_${itemId}_${contentIndex}` : outputIndex !== undefined && contentIndex !== undefined ? `resp_part_out_${outputIndex}_${contentIndex}` : "";
+    if (key) {
+      const existing = ctx.streamState.get(key);
+      if (typeof existing === "number" && Number.isFinite(existing))
+        return existing;
+      const assigned2 = this.nextResponsesContentIndex(ctx);
+      ctx.streamState.set(key, assigned2);
+      return assigned2;
+    }
+    const fallback = ctx.streamState.get("resp_fallback_text_index");
+    if (typeof fallback === "number" && Number.isFinite(fallback))
+      return fallback;
+    const assigned = this.nextResponsesContentIndex(ctx);
+    ctx.streamState.set("resp_fallback_text_index", assigned);
+    return assigned;
+  }
+  ensureResponsesTextBlockStarted(events, ctx, index) {
+    const key = `resp_text_block_${index}`;
+    if (ctx.streamState.get(key) === true)
+      return;
+    events.push({
+      type: "content_block_start",
+      index,
+      content_block: { type: "text", text: "" }
+    });
+    ctx.streamState.set(key, true);
+  }
+  resolveResponsesToolIndex(chunk, ctx) {
+    const itemId = typeof chunk?.item_id === "string" ? chunk.item_id : "";
+    if (itemId) {
+      const byItem = ctx.streamState.get(`resp_tool_item_${itemId}`);
+      if (typeof byItem === "number" && Number.isFinite(byItem))
+        return byItem;
+    }
+    const outputIndex = typeof chunk?.output_index === "number" ? chunk.output_index : undefined;
+    if (outputIndex !== undefined) {
+      const byOutput = ctx.streamState.get(`resp_tool_out_${outputIndex}`);
+      if (typeof byOutput === "number" && Number.isFinite(byOutput))
+        return byOutput;
+    }
+    const last = ctx.streamState.get("resp_last_tool_index");
+    return typeof last === "number" && Number.isFinite(last) ? last : undefined;
+  }
   ensureResponsesThinkingBlockStarted(events, ctx, index) {
     const blockKey = `resp_reasoning_block_${index}`;
     if (ctx.streamState.get(blockKey) === true) {
@@ -4305,15 +4330,16 @@ ${block.thinking || ""}
   convertOpenAIResponsesToAnthropic(openaiBody) {
     const content = [];
     const output = Array.isArray(openaiBody.output) ? openaiBody.output : [];
+    let hasToolUse = false;
     for (const item of output) {
       if (!item || typeof item !== "object")
         continue;
       if (item.type === "reasoning") {
-        const summaryTexts = this.extractReasoningSummaryTexts(item);
-        for (const summaryText of summaryTexts) {
+        const thinkingText = this.extractStrictResponsesReasoningText(item);
+        if (thinkingText) {
           content.push({
             type: "thinking",
-            thinking: summaryText
+            thinking: thinkingText
           });
         }
         continue;
@@ -4337,6 +4363,7 @@ ${block.thinking || ""}
           name: item.name || "",
           input: parsedInput
         });
+        hasToolUse = true;
         continue;
       }
       if (item.type === "message" && Array.isArray(item.content)) {
@@ -4344,28 +4371,64 @@ ${block.thinking || ""}
           if (!part || typeof part !== "object")
             continue;
           if (part.type === "output_text" && typeof part.text === "string") {
-            content.push(...parseThinkingTags2(part.text));
+            if (part.text)
+              content.push({ type: "text", text: part.text });
             continue;
           }
-          if (part.type === "text" && typeof part.text === "string") {
-            content.push(...parseThinkingTags2(part.text));
+          if (part.type === "refusal" && typeof part.refusal === "string") {
+            if (part.refusal)
+              content.push({ type: "text", text: part.refusal });
           }
         }
       }
     }
-    const stopReason = content.some((block) => block.type === "tool_use") ? "tool_use" : openaiBody.status === "incomplete" ? "max_tokens" : "end_turn";
+    const stopReason = this.mapResponsesStopReason(openaiBody.status, hasToolUse, openaiBody.incomplete_details?.reason);
+    const usage = this.buildAnthropicUsageFromResponses(openaiBody.usage);
     return {
-      id: openaiBody.id || generateAnthropicMessageId(),
+      id: typeof openaiBody.id === "string" ? openaiBody.id : "",
       type: "message",
       role: "assistant",
       content,
-      model: openaiBody.model || "gpt-4",
+      model: typeof openaiBody.model === "string" ? openaiBody.model : "",
       stop_reason: stopReason,
-      usage: {
-        input_tokens: openaiBody.usage?.input_tokens || 0,
-        output_tokens: openaiBody.usage?.output_tokens || 0
-      }
+      stop_sequence: null,
+      usage
+    };
+  }
+  mapResponsesStopReason(status, hasToolUse, incompleteReason) {
+    if (typeof status !== "string") {
+      return null;
+    }
+    if (status === "completed") {
+      return hasToolUse ? "tool_use" : "end_turn";
+    }
+    if (status === "incomplete") {
+      return incompleteReason === undefined || incompleteReason === "max_output_tokens" || incompleteReason === "max_tokens" ? "max_tokens" : "end_turn";
+    }
+    return "end_turn";
+  }
+  buildAnthropicUsageFromResponses(usage) {
+    if (!usage || typeof usage !== "object") {
+      return { input_tokens: 0, output_tokens: 0 };
+    }
+    const result = {
+      input_tokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+      output_tokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
     };
+    const cachedFromInput = usage.input_tokens_details?.cached_tokens;
+    const cachedFromPrompt = usage.prompt_tokens_details?.cached_tokens;
+    if (typeof cachedFromInput === "number") {
+      result.cache_read_input_tokens = cachedFromInput;
+    } else if (typeof cachedFromPrompt === "number") {
+      result.cache_read_input_tokens = cachedFromPrompt;
+    }
+    if (usage.cache_read_input_tokens !== undefined) {
+      result.cache_read_input_tokens = usage.cache_read_input_tokens;
+    }
+    if (usage.cache_creation_input_tokens !== undefined) {
+      result.cache_creation_input_tokens = usage.cache_creation_input_tokens;
+    }
+    return result;
   }
   convertOpenAIResponseToAnthropic(openaiBody) {
     const choice = openaiBody.choices?.[0];
@@ -4385,77 +4448,90 @@ ${block.thinking || ""}
     }
     const message = choice.message;
     const content = [];
-    const seenThinking = new Set;
-    this.appendUniqueThinkingBlocks(content, this.extractChatCompletionReasoningTexts(message), seenThinking);
-    if (Array.isArray(message.tool_calls)) {
-      for (const tc of message.tool_calls) {
-        let parsedInput = {};
-        try {
-          const parsedValue = JSON.parse(tc.function?.arguments || "{}");
-          if (parsedValue && typeof parsedValue === "object" && !Array.isArray(parsedValue)) {
-            parsedInput = parsedValue;
-          }
-        } catch {
-          parsedInput = {};
-        }
-        content.push({
-          type: "tool_use",
-          id: tc.id || "",
-          name: tc.function?.name || "",
-          input: parsedInput
-        });
-      }
+    const hasToolCalls2 = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+    if (message.refusal && typeof message.refusal === "string") {
+      content.push({
+        type: "text",
+        text: message.refusal
+      });
     }
     if (typeof message.content === "string" && message.content.length > 0) {
-      const parsedContent = parseThinkingTags2(message.content);
-      this.appendParsedContent(content, parsedContent, seenThinking);
+      content.push({ type: "text", text: message.content });
     } else if (Array.isArray(message.content)) {
       for (const part of message.content) {
-        if (part?.type === "text" && typeof part.text === "string") {
-          this.appendParsedContent(content, parseThinkingTags2(part.text), seenThinking);
+        if ((part?.type === "text" || part?.type === "output_text") && typeof part.text === "string") {
+          if (part.text)
+            content.push({ type: "text", text: part.text });
           continue;
         }
-        if (typeof part === "string") {
-          this.appendParsedContent(content, parseThinkingTags2(part), seenThinking);
+        if (part?.type === "refusal" && typeof part.refusal === "string") {
+          if (part.refusal)
+            content.push({ type: "text", text: part.refusal });
           continue;
         }
-        if (part && typeof part === "object") {
-          const partType = typeof part.type === "string" ? part.type : "";
-          if (partType === "reasoning" || partType === "thinking" || part.thought === true) {
-            this.appendUniqueThinkingBlocks(content, this.extractReasoningSummaryTexts(part), seenThinking);
-            continue;
-          }
-          if (part.type === "image_url" && typeof part.image_url?.url === "string") {
-            const source = this.parseOpenAIImageUrlSource(part.image_url.url);
-            if (source) {
-              content.push({
-                type: "image",
-                source
-              });
-              continue;
-            }
-          }
-          content.push({
-            type: "text",
-            text: JSON.stringify(part)
-          });
-        }
       }
     }
-    const stopReason = mapOpenAIFinishReasonToAnthropic(choice.finish_reason || "stop");
+    if (hasToolCalls2) {
+      for (const tc of message.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: tc.id || "",
+          name: tc.function?.name || "",
+          input: this.parseToolArguments(tc.function?.arguments)
+        });
+      }
+    }
+    if (!hasToolCalls2 && message.function_call) {
+      const functionCall = message.function_call;
+      const hasArguments = functionCall.arguments !== undefined;
+      const name = typeof functionCall.name === "string" ? functionCall.name : "";
+      if (name || hasArguments) {
+        content.push({
+          type: "tool_use",
+          id: typeof functionCall.id === "string" ? functionCall.id : "",
+          name,
+          input: typeof functionCall.arguments === "string" ? this.parseToolArguments(functionCall.arguments) : functionCall.arguments && typeof functionCall.arguments === "object" ? functionCall.arguments : {}
+        });
+      }
+    }
+    let stopReason = mapOpenAIFinishReasonToAnthropic(choice.finish_reason || "stop");
+    if (!choice.finish_reason && content.some((block) => block.type === "tool_use")) {
+      stopReason = "tool_use";
+    }
+    const usage = {
+      input_tokens: openaiBody.usage?.prompt_tokens ?? openaiBody.usage?.input_tokens ?? 0,
+      output_tokens: openaiBody.usage?.completion_tokens ?? openaiBody.usage?.output_tokens ?? 0
+    };
+    const cacheReadTokens = openaiBody.usage?.prompt_tokens_details?.cached_tokens ?? openaiBody.usage?.cache_read_input_tokens;
+    if (typeof cacheReadTokens === "number") {
+      usage.cache_read_input_tokens = cacheReadTokens;
+    }
+    const cacheCreationTokens = openaiBody.usage?.cache_creation_input_tokens;
+    if (typeof cacheCreationTokens === "number") {
+      usage.cache_creation_input_tokens = cacheCreationTokens;
+    }
     return {
-      id: openaiBody.id || generateAnthropicMessageId(),
+      id: typeof openaiBody.id === "string" ? openaiBody.id : "",
       type: "message",
       role: "assistant",
       content,
-      model: openaiBody.model || "gpt-4",
+      model: typeof openaiBody.model === "string" ? openaiBody.model : "",
       stop_reason: stopReason,
-      usage: {
-        input_tokens: openaiBody.usage?.prompt_tokens || 0,
-        output_tokens: openaiBody.usage?.completion_tokens || 0
-      }
+      stop_sequence: null,
+      usage
     };
   }
+  parseToolArguments(argumentsValue) {
+    if (typeof argumentsValue !== "string") {
+      return {};
+    }
+    try {
+      const parsedValue = JSON.parse(argumentsValue || "{}");
+      return parsedValue && typeof parsedValue === "object" && !Array.isArray(parsedValue) ? parsedValue : {};
+    } catch {
+      return {};
+    }
+  }
   async processStreamChunk(chunk, ctx) {
     if (this.isResponsesStreamChunk(chunk)) {
       return this.processResponsesStreamChunk(chunk, ctx);
@@ -4489,7 +4565,7 @@ ${block.thinking || ""}
     const deltaText = this.extractDeltaText(delta?.content);
     const finishReason = choice.finish_reason;
     if (!ctx.streamState.has("message_started")) {
-      if (delta && (delta.content || delta.tool_calls || delta.role || thinkingDeltaText)) {
+      if (delta && (delta.content || delta.tool_calls || delta.function_call || delta.role || thinkingDeltaText)) {
         events.push({
           type: "message_start",
           message: {
@@ -4497,14 +4573,20 @@ ${block.thinking || ""}
             type: "message",
             role: "assistant",
             content: [],
-            model: chunk.model || "gpt-4",
-            usage: { input_tokens: 0, output_tokens: 0 }
+            model: chunk.model || "",
+            usage: streamUsage || { input_tokens: 0, output_tokens: 0 }
           }
         });
         ctx.streamState.set("message_started", true);
       }
     }
     if (thinkingDeltaText) {
+      const textIndex = ctx.streamState.get("chat_text_index");
+      if (typeof textIndex === "number" && Number.isFinite(textIndex)) {
+        events.push({ type: "content_block_stop", index: textIndex });
+        ctx.streamState.delete("chat_text_index");
+        ctx.streamState.delete("text_block_started");
+      }
       const thinkingIndex = this.ensureChatThinkingBlockStarted(events, ctx);
       events.push({
         type: "content_block_delta",
@@ -4516,6 +4598,11 @@ ${block.thinking || ""}
       });
     }
     if (deltaText) {
+      const thinkingIndex = ctx.streamState.get("chat_thinking_index");
+      if (typeof thinkingIndex === "number" && Number.isFinite(thinkingIndex)) {
+        events.push({ type: "content_block_stop", index: thinkingIndex });
+        ctx.streamState.delete("chat_thinking_index");
+      }
       const textIndex = this.ensureChatTextBlockStarted(events, ctx);
       events.push({
         type: "content_block_delta",
@@ -4526,7 +4613,8 @@ ${block.thinking || ""}
         }
       });
     }
-    if (delta.tool_calls) {
+    if (delta?.tool_calls) {
+      this.closeChatNonToolBlock(events, ctx);
       for (const tc of delta.tool_calls) {
         const rawIndex = typeof tc.index === "number" ? tc.index : 0;
         const index = this.resolveChatToolIndex(rawIndex, ctx);
@@ -4535,52 +4623,123 @@ ${block.thinking || ""}
           ctx.streamState.set(toolKey, {
             id: tc.id || "",
             name: tc.function?.name || "",
-            arguments: ""
+            arguments: "",
+            started: false
           });
+        }
+        const toolState = ctx.streamState.get(toolKey);
+        if (typeof tc.id === "string")
+          toolState.id = tc.id;
+        if (typeof tc.function?.name === "string")
+          toolState.name = tc.function.name;
+        const argsDelta = typeof tc.function?.arguments === "string" ? tc.function.arguments : "";
+        if (!toolState.started && toolState.id && toolState.name) {
+          toolState.started = true;
           events.push({
             type: "content_block_start",
             index,
             content_block: {
               type: "tool_use",
-              id: tc.id || "",
-              name: tc.function?.name || "",
+              id: toolState.id,
+              name: toolState.name,
               input: {}
             }
           });
+          if (toolState.arguments) {
+            events.push({
+              type: "content_block_delta",
+              index,
+              delta: {
+                type: "input_json_delta",
+                partial_json: toolState.arguments
+              }
+            });
+            toolState.arguments = "";
+          }
         }
-        const toolState = ctx.streamState.get(toolKey);
-        if (tc.function?.arguments) {
-          toolState.arguments += tc.function.arguments;
+        if (argsDelta) {
+          if (toolState.started) {
+            events.push({
+              type: "content_block_delta",
+              index,
+              delta: {
+                type: "input_json_delta",
+                partial_json: argsDelta
+              }
+            });
+          } else {
+            toolState.arguments += argsDelta;
+          }
           ctx.streamState.set(toolKey, toolState);
-          events.push({
-            type: "content_block_delta",
-            index,
-            delta: {
-              type: "input_json_delta",
-              partial_json: tc.function.arguments
-            }
-          });
         }
       }
     }
-    if (finishReason) {
-      const textIndex = ctx.streamState.get("chat_text_index");
-      if (typeof textIndex === "number" && Number.isFinite(textIndex)) {
+    if (delta?.function_call) {
+      this.closeChatNonToolBlock(events, ctx);
+      const functionCall = delta.function_call;
+      if (typeof functionCall.name === "string") {
+        ctx.streamState.set("legacy_function_name", functionCall.name);
+      }
+      if (!ctx.streamState.has("legacy_function_index")) {
+        const index2 = this.allocateChatContentBlockIndex(ctx, 0, 0);
+        ctx.streamState.set("legacy_function_index", index2);
         events.push({
-          type: "content_block_stop",
-          index: textIndex
+          type: "content_block_start",
+          index: index2,
+          content_block: {
+            type: "tool_use",
+            id: "",
+            name: ctx.streamState.get("legacy_function_name") || "",
+            input: {}
+          }
         });
       }
-      const thinkingIndex = ctx.streamState.get("chat_thinking_index");
-      if (typeof thinkingIndex === "number" && Number.isFinite(thinkingIndex)) {
+      const index = ctx.streamState.get("legacy_function_index");
+      if (typeof functionCall.arguments === "string" && functionCall.arguments.length > 0) {
         events.push({
-          type: "content_block_stop",
-          index: thinkingIndex
+          type: "content_block_delta",
+          index,
+          delta: {
+            type: "input_json_delta",
+            partial_json: functionCall.arguments
+          }
         });
       }
+    }
+    if (finishReason) {
+      this.closeChatNonToolBlock(events, ctx);
+      const legacyFunctionIndex = ctx.streamState.get("legacy_function_index");
+      if (typeof legacyFunctionIndex === "number" && Number.isFinite(legacyFunctionIndex)) {
+        events.push({ type: "content_block_stop", index: legacyFunctionIndex });
+      }
       const toolKeys = Array.from(ctx.streamState.keys()).filter((k) => k.startsWith("tool_")).sort((a, b) => Number(a.slice(5)) - Number(b.slice(5)));
       for (const toolKey of toolKeys) {
         const toolIndex = Number(toolKey.slice(5));
+        const toolState = ctx.streamState.get(toolKey);
+        if (toolState && !toolState.started && (toolState.arguments || toolState.id || toolState.name)) {
+          const fallbackId = toolState.id || `tool_call_${toolIndex}`;
+          const fallbackName = toolState.name || "unknown_tool";
+          events.push({
+            type: "content_block_start",
+            index: Number.isFinite(toolIndex) ? toolIndex : 0,
+            content_block: {
+              type: "tool_use",
+              id: fallbackId,
+              name: fallbackName,
+              input: {}
+            }
+          });
+          if (toolState.arguments) {
+            events.push({
+              type: "content_block_delta",
+              index: Number.isFinite(toolIndex) ? toolIndex : 0,
+              delta: {
+                type: "input_json_delta",
+                partial_json: toolState.arguments
+              }
+            });
+          }
+        }
         events.push({
           type: "content_block_stop",
           index: Number.isFinite(toolIndex) ? toolIndex : 0
@@ -4659,8 +4818,8 @@ ${block.thinking || ""}
             type: "message",
             role: "assistant",
             content: [],
-            model: chunk.response?.model || "gpt-4",
-            usage: { input_tokens: 0, output_tokens: 0 }
+            model: chunk.response?.model || "",
+            usage: this.buildAnthropicUsageFromResponses(chunk.response?.usage)
           }
         });
         ctx.streamState.set("message_started", true);
@@ -4681,22 +4840,42 @@ ${block.thinking || ""}
       ensureMessageStarted();
       return this.finalizeResponsesStreamEvents(events, ctx);
     }
-    if (eventType === "response.in_progress" || eventType === "keepalive") {
+    if (eventType === "response.content_part.added") {
       ensureMessageStarted();
-      events.push({
-        type: "ping"
-      });
+      const partType = chunk.part?.type;
+      if (partType === "output_text" || partType === "refusal") {
+        const index = this.resolveResponsesContentIndex(chunk, ctx);
+        this.ensureResponsesTextBlockStarted(events, ctx, index);
+      }
+      return this.finalizeResponsesStreamEvents(events, ctx);
+    }
+    if (eventType === "response.content_part.done" || eventType === "response.refusal.done" || eventType === "response.reasoning.done") {
+      const index = this.resolveResponsesContentIndex(chunk, ctx);
+      if (ctx.streamState.get(`resp_text_block_${index}`) === true || ctx.streamState.get(`resp_reasoning_block_${index}`) === true) {
+        events.push({ type: "content_block_stop", index });
+        ctx.streamState.delete(`resp_text_block_${index}`);
+        ctx.streamState.delete(`resp_reasoning_block_${index}`);
+      }
+      return this.finalizeResponsesStreamEvents(events, ctx);
+    }
+    if (eventType === "response.in_progress" || eventType === "keepalive") {
       return this.finalizeResponsesStreamEvents(events, ctx);
     }
     if (eventType === "response.output_item.added") {
       const item = chunk.item;
       if (item?.type === "function_call") {
-        const rawIndex = typeof chunk.output_index === "number" ? chunk.output_index + 1 : typeof item.output_index === "number" ? item.output_index + 1 : 1;
-        const index = Number.isFinite(rawIndex) ? rawIndex : 1;
+        const index = this.nextResponsesContentIndex(ctx);
         const metaKey = `resp_tool_meta_${index}`;
         const callId = typeof item.call_id === "string" ? item.call_id : typeof item.id === "string" ? item.id : `tool_${index}`;
         const name = typeof item.name === "string" ? item.name : "tool";
         ctx.streamState.set(metaKey, { callId, name });
+        if (typeof item.id === "string")
+          ctx.streamState.set(`resp_tool_item_${item.id}`, index);
+        if (typeof chunk.item_id === "string")
+          ctx.streamState.set(`resp_tool_item_${chunk.item_id}`, index);
+        if (typeof chunk.output_index === "number")
+          ctx.streamState.set(`resp_tool_out_${chunk.output_index}`, index);
+        ctx.streamState.set("resp_last_tool_index", index);
         if (!ctx.streamState.has("message_started")) {
           events.push({
             type: "message_start",
@@ -4705,7 +4884,7 @@ ${block.thinking || ""}
               type: "message",
               role: "assistant",
               content: [],
-              model: chunk.response?.model || "gpt-4",
+              model: chunk.response?.model || "",
               usage: { input_tokens: 0, output_tokens: 0 }
             }
           });
@@ -4734,8 +4913,7 @@ ${block.thinking || ""}
     if (eventType === "response.output_item.done") {
       const item = chunk.item;
       if (item?.type === "function_call") {
-        const rawIndex = typeof chunk.output_index === "number" ? chunk.output_index + 1 : typeof item.output_index === "number" ? item.output_index + 1 : 1;
-        const index = Number.isFinite(rawIndex) ? rawIndex : 1;
+        const index = this.resolveResponsesToolIndex({ ...chunk, item_id: chunk.item_id || item.id }, ctx) ?? this.nextResponsesContentIndex(ctx);
         const toolKey = `resp_tool_${index}`;
         const metaKey = `resp_tool_meta_${index}`;
         const meta = ctx.streamState.get(metaKey);
@@ -4749,7 +4927,7 @@ ${block.thinking || ""}
               type: "message",
               role: "assistant",
               content: [],
-              model: chunk.response?.model || "gpt-4",
+              model: chunk.response?.model || "",
               usage: { input_tokens: 0, output_tokens: 0 }
             }
           });
@@ -4787,8 +4965,10 @@ ${block.thinking || ""}
       return this.finalizeResponsesStreamEvents(events, ctx);
     }
     if (eventType === "response.function_call_arguments.done") {
-      const rawIndex = typeof chunk.output_index === "number" ? chunk.output_index + 1 : 1;
-      const index = Number.isFinite(rawIndex) ? rawIndex : 1;
+      const index = this.resolveResponsesToolIndex(chunk, ctx);
+      if (index === undefined) {
+        return this.finalizeResponsesStreamEvents(events, ctx);
+      }
       const toolKey = `resp_tool_${index}`;
       const metaKey = `resp_tool_meta_${index}`;
       const meta = ctx.streamState.get(metaKey);
@@ -4802,7 +4982,7 @@ ${block.thinking || ""}
             type: "message",
             role: "assistant",
             content: [],
-            model: chunk.response?.model || "gpt-4",
+            model: chunk.response?.model || "",
             usage: { input_tokens: 0, output_tokens: 0 }
           }
         });
@@ -4821,36 +5001,24 @@ ${block.thinking || ""}
           }
         });
       }
-      const hasDeltaKey = `resp_tool_has_delta_${index}`;
-      const hasDelta = ctx.streamState.get(hasDeltaKey) === true;
-      const fullArgsSentKey = `resp_tool_full_args_sent_${index}`;
-      const fullArgsSent = ctx.streamState.get(fullArgsSentKey) === true;
-      const argsDoneSeenKey = `resp_tool_args_done_seen_${index}`;
-      const argsDoneSeen = ctx.streamState.get(argsDoneSeenKey) === true;
-      const doneArgsKey = `resp_tool_done_arguments_${index}`;
-      const previousDoneArgs = ctx.streamState.get(doneArgsKey);
-      const fullArgs = typeof chunk.arguments === "string" ? chunk.arguments : "";
-      if (argsDoneSeen && (fullArgsSent || hasDelta || fullArgs && previousDoneArgs === fullArgs)) {
-        return this.finalizeResponsesStreamEvents(events, ctx);
-      }
-      ctx.streamState.set(argsDoneSeenKey, true);
-      if (fullArgs) {
-        ctx.streamState.set(doneArgsKey, fullArgs);
-      }
-      if (fullArgs && !hasDelta && !fullArgsSent) {
-        ctx.streamState.set(fullArgsSentKey, true);
+      const doneArguments = typeof chunk.arguments === "string" ? chunk.arguments : "";
+      const hasDelta = ctx.streamState.get(`resp_tool_has_delta_${index}`) === true;
+      if (doneArguments && !hasDelta) {
+        ctx.streamState.set(`resp_tool_has_delta_${index}`, true);
         events.push({
           type: "content_block_delta",
           index,
           delta: {
             type: "input_json_delta",
-            partial_json: fullArgs
+            partial_json: doneArguments
           }
         });
       }
+      events.push({ type: "content_block_stop", index });
+      ctx.streamState.set(`resp_tool_closed_${index}`, true);
       return this.finalizeResponsesStreamEvents(events, ctx);
     }
-    if (!ctx.streamState.has("message_started") && eventType === "response.output_text.delta") {
+    if (!ctx.streamState.has("message_started") && (eventType === "response.output_text.delta" || eventType === "response.refusal.delta")) {
       events.push({
         type: "message_start",
         message: {
@@ -4858,29 +5026,20 @@ ${block.thinking || ""}
           type: "message",
           role: "assistant",
           content: [],
-          model: chunk.response?.model || "gpt-4",
+          model: chunk.response?.model || "",
           usage: { input_tokens: 0, output_tokens: 0 }
         }
       });
       ctx.streamState.set("message_started", true);
     }
-    if (eventType === "response.output_text.delta") {
-      if (!ctx.streamState.has("text_block_started")) {
-        events.push({
-          type: "content_block_start",
-          index: 0,
-          content_block: {
-            type: "text",
-            text: ""
-          }
-        });
-        ctx.streamState.set("text_block_started", true);
-      }
+    if (eventType === "response.output_text.delta" || eventType === "response.refusal.delta") {
+      const index = this.resolveResponsesContentIndex(chunk, ctx);
+      this.ensureResponsesTextBlockStarted(events, ctx, index);
       const deltaText = typeof chunk.delta === "string" ? chunk.delta : typeof chunk.text === "string" ? chunk.text : "";
       if (deltaText) {
         events.push({
           type: "content_block_delta",
-          index: 0,
+          index,
           delta: {
             type: "text_delta",
             text: deltaText
@@ -4915,8 +5074,7 @@ ${block.thinking || ""}
       return this.finalizeResponsesStreamEvents(events, ctx);
     }
     if (eventType === "response.function_call_arguments.delta") {
-      const rawIndex = typeof chunk.output_index === "number" ? chunk.output_index + 1 : 1;
-      const index = Number.isFinite(rawIndex) ? rawIndex : 1;
+      const index = this.resolveResponsesToolIndex(chunk, ctx) ?? this.nextResponsesContentIndex(ctx);
       const argsDoneSeen = ctx.streamState.get(`resp_tool_args_done_seen_${index}`) === true;
       const fullArgsSent = ctx.streamState.get(`resp_tool_full_args_sent_${index}`) === true;
       if (argsDoneSeen || fullArgsSent) {
@@ -4930,13 +5088,16 @@ ${block.thinking || ""}
             type: "message",
             role: "assistant",
             content: [],
-            model: chunk.response?.model || "gpt-4",
+            model: chunk.response?.model || "",
             usage: { input_tokens: 0, output_tokens: 0 }
           }
         });
         ctx.streamState.set("message_started", true);
       }
       const toolKey = `resp_tool_${index}`;
+      if (ctx.streamState.get(`resp_tool_closed_${index}`) === true) {
+        return this.finalizeResponsesStreamEvents(events, ctx);
+      }
       const metaKey = `resp_tool_meta_${index}`;
       const meta = ctx.streamState.get(metaKey);
       const callId = typeof chunk.call_id === "string" ? chunk.call_id : typeof meta?.callId === "string" ? meta.callId : typeof chunk.item_id === "string" ? chunk.item_id : `tool_${index}`;
@@ -4978,17 +5139,16 @@ ${block.thinking || ""}
             type: "message",
             role: "assistant",
             content: [],
-            model: chunk.response?.model || "gpt-4",
+            model: chunk.response?.model || "",
             usage: { input_tokens: 0, output_tokens: 0 }
           }
         });
         ctx.streamState.set("message_started", true);
       }
-      if (ctx.streamState.has("text_block_started")) {
-        events.push({
-          type: "content_block_stop",
-          index: 0
-        });
+      const textBlockKeys = Array.from(ctx.streamState.keys()).filter((k) => typeof k === "string" && /^resp_text_block_\d+$/.test(k)).sort((a, b) => Number(a.slice("resp_text_block_".length)) - Number(b.slice("resp_text_block_".length)));
+      for (const blockKey of textBlockKeys) {
+        const textIndex = Number(blockKey.slice("resp_text_block_".length));
+        events.push({ type: "content_block_stop", index: Number.isFinite(textIndex) ? textIndex : 0 });
       }
       const reasoningBlockKeys = Array.from(ctx.streamState.keys()).filter((k) => typeof k === "string" && /^resp_reasoning_block_\d+$/.test(k)).sort((a, b) => Number(a.slice("resp_reasoning_block_".length)) - Number(b.slice("resp_reasoning_block_".length)));
       for (const blockKey of reasoningBlockKeys) {
@@ -5001,20 +5161,22 @@ ${block.thinking || ""}
       const toolKeys = Array.from(ctx.streamState.keys()).filter((k) => typeof k === "string" && /^resp_tool_\d+$/.test(k)).sort((a, b) => Number(a.slice(10)) - Number(b.slice(10)));
       for (const toolKey of toolKeys) {
         const toolIndex = Number(toolKey.slice(10));
+        if (ctx.streamState.get(`resp_tool_closed_${toolIndex}`) === true) {
+          continue;
+        }
         events.push({
           type: "content_block_stop",
           index: Number.isFinite(toolIndex) ? toolIndex : 1
         });
       }
       const usage = chunk.response?.usage && typeof chunk.response.usage === "object" ? chunk.response.usage : chunk.usage;
-      const normalizedUsage = usage ? {
-        input_tokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
-        output_tokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
-      } : undefined;
+      const normalizedUsage = usage ? this.buildAnthropicUsageFromResponses(usage) : undefined;
+      const responseStatus = typeof chunk.response?.status === "string" ? chunk.response.status : eventType === "response.completed" ? "completed" : eventType === "response.incomplete" ? "incomplete" : "failed";
+      const hasToolUse = toolKeys.length > 0;
       events.push({
         type: "message_delta",
         delta: {
-          stop_reason: toolKeys.length > 0 ? "tool_use" : eventType === "response.incomplete" ? "max_tokens" : "end_turn"
+          stop_reason: this.mapResponsesStopReason(responseStatus, hasToolUse, chunk.response?.incomplete_details?.reason)
         },
         ...normalizedUsage && { usage: normalizedUsage }
       });
@@ -5197,10 +5359,14 @@ class GeminiToAnthropicConverter {
           const text = part.text.trim();
           if (text) {
             if (part.thought) {
-              anthropicContent.push({
+              const thinkingBlock = {
                 type: "thinking",
                 thinking: text
-              });
+              };
+              if (part.thoughtSignature) {
+                thinkingBlock.thought_signature = part.thoughtSignature;
+              }
+              anthropicContent.push(thinkingBlock);
             } else {
               anthropicContent.push({
                 type: "text",
@@ -5223,12 +5389,16 @@ class GeminiToAnthropicConverter {
           const queue = pendingToolUseIdsByName.get(fc.name) || [];
           queue.push(toolUseId);
           pendingToolUseIdsByName.set(fc.name, queue);
-          anthropicContent.push({
+          const toolUseBlock = {
             type: "tool_use",
             id: toolUseId,
             name: fc.name,
             input: fc.args || {}
-          });
+          };
+          if (part.thoughtSignature) {
+            toolUseBlock.thought_signature = part.thoughtSignature;
+          }
+          anthropicContent.push(toolUseBlock);
         } else if (part.functionResponse) {
           const fr = part.functionResponse;
           const respContent = typeof fr.response === "object" ? fr.response.content || JSON.stringify(fr.response) : String(fr.response);
@@ -5421,15 +5591,23 @@ class GeminiToAnthropicConverter {
         } else if (item.type === "thinking") {
           const thinking = item.thinking || "";
           if (thinking.trim()) {
-            parts.push({ text: thinking, thought: true });
+            const thinkingPart = { text: thinking, thought: true };
+            if (item.thought_signature) {
+              thinkingPart.thoughtSignature = item.thought_signature;
+            }
+            parts.push(thinkingPart);
           }
         } else if (item.type === "tool_use") {
-          parts.push({
+          const fcPart = {
             functionCall: {
               name: item.name || "",
               args: item.input || {}
             }
-          });
+          };
+          if (item.thought_signature) {
+            fcPart.thoughtSignature = item.thought_signature;
+          }
+          parts.push(fcPart);
         }
       }
     }
@@ -5464,7 +5642,15 @@ class GeminiToAnthropicConverter {
   }
   async processStreamChunk(chunk, ctx) {
     const eventType = chunk.type;
-    if (eventType === "message_start" || eventType === "content_block_start" || eventType === "content_block_stop" || eventType === "message_stop" || eventType === "ping") {
+    if (eventType === "content_block_start") {
+      const block = chunk.content_block;
+      if (block && block.thought_signature) {
+        const idx = chunk.index ?? 0;
+        ctx.streamState.set(`part_${idx}_sig`, block.thought_signature);
+      }
+      return [];
+    }
+    if (eventType === "message_start" || eventType === "content_block_stop" || eventType === "message_stop" || eventType === "ping") {
       return [];
     }
     if (eventType === "content_block_delta") {
@@ -5490,7 +5676,12 @@ class GeminiToAnthropicConverter {
         accumulatedThinking += delta.thinking || "";
         ctx.streamState.set("accumulated_thinking", accumulatedThinking);
         if (accumulatedThinking) {
-          parts.push({ text: accumulatedThinking, thought: true });
+          const thinkingPart = { text: accumulatedThinking, thought: true };
+          const sig = ctx.streamState.get(`part_${chunk.index ?? 0}_sig`);
+          if (sig) {
+            thinkingPart.thoughtSignature = sig;
+          }
+          parts.push(thinkingPart);
         }
       } else if (delta.type === "input_json_delta") {
         return [];
@@ -5640,7 +5831,7 @@ class GeminiToOpenAIConverter {
               const queue = pendingToolCallIdsByName.get(functionName) || [];
               queue.push(toolCallId);
               pendingToolCallIdsByName.set(functionName, queue);
-              return {
+              const tc = {
                 id: toolCallId,
                 type: "function",
                 function: {
@@ -5648,6 +5839,10 @@ class GeminiToOpenAIConverter {
                   arguments: JSON.stringify(p.functionCall.args || {})
                 }
               };
+              if (p.thoughtSignature) {
+                tc.extra_content = { google: { thought_signature: p.thoughtSignature } };
+              }
+              return tc;
             })
           });
         } else {
@@ -5835,12 +6030,17 @@ class GeminiToOpenAIConverter {
     const parts = [];
     if (message.tool_calls) {
       for (const tc of message.tool_calls) {
-        parts.push({
+        const fcPart = {
           functionCall: {
             name: tc.function.name,
             args: this.parseToolArgumentsToObject(tc.function.arguments)
           }
-        });
+        };
+        const sig = tc.extra_content?.google?.thought_signature || tc.thought_signature;
+        if (sig) {
+          fcPart.thoughtSignature = sig;
+        }
+        parts.push(fcPart);
       }
     } else if (message.content) {
       parts.push({ text: message.content });
@@ -6321,12 +6521,19 @@ class OpenAIToGeminiConverter {
           role: "model",
           parts: [
             ...textParts,
-            ...m.tool_calls.map((tc) => ({
-              functionCall: {
-                name: tc.function.name,
-                args: this.parseToolArgumentsToObject(tc.function.arguments)
+            ...m.tool_calls.map((tc) => {
+              const fcPart = {
+                functionCall: {
+                  name: tc.function.name,
+                  args: this.parseToolArgumentsToObject(tc.function.arguments)
+                }
+              };
+              const sig = tc.extra_content?.google?.thought_signature || tc.thought_signature;
+              if (sig) {
+                fcPart.thoughtSignature = sig;
               }
-            }))
+              return fcPart;
+            })
           ]
         };
       }
@@ -6528,14 +6735,18 @@ class OpenAIToGeminiConverter {
       if (part.text) {
         textContent += part.text;
       } else if (part.functionCall) {
-        toolCalls.push({
+        const tc = {
           id: `call_${part.functionCall.name}_${index}`,
           type: "function",
           function: {
             name: part.functionCall.name,
             arguments: JSON.stringify(part.functionCall.args || {})
           }
-        });
+        };
+        if (part.thoughtSignature) {
+          tc.extra_content = { google: { thought_signature: part.thoughtSignature } };
+        }
+        toolCalls.push(tc);
       }
     }
     const message = { role: "assistant" };