fix(anthropic): preserve thinking signatures for Claude Code compatibility

Claude's API requires valid signatures on thinking blocks. This change:
- Extract thinking blocks and signatures from Anthropic format in translator
- Pass thought_signature through streaming pipeline with signature_delta
- Use tool_call_id as primary cache key (more stable than text hash)
- Only inject thinking when valid signature is available
- Add final safety check to ensure clean state when signatures missing

Fixes 400 errors when using Claude models through Claude Code.

Author: FammasMaz

src/rotator_library/anthropic_compat/streaming.py

@@ -49,6 +49,7 @@ async def anthropic_streaming_wrapper(
     message_started = False
     content_block_started = False
     thinking_block_started = False
+    thinking_signature = ""  # Store signature for thinking block
     current_block_index = 0
     tool_calls_by_index = {}  # Track tool calls by their index
     tool_block_indices = {}  # Track which block index each tool call uses
@@ -87,9 +88,18 @@ async def anthropic_streaming_wrapper(
 
                 # Close any open thinking block
                 if thinking_block_started:
+                    # Send signature_delta if we have a signature
+                    if thinking_signature:
+                        sig_delta = {
+                            "type": "content_block_delta",
+                            "index": current_block_index,
+                            "delta": {"type": "signature_delta", "signature": thinking_signature},
+                        }
+                        yield f"event: content_block_delta\ndata: {json.dumps(sig_delta)}\n\n"
                     yield f'event: content_block_stop\ndata: {{"type": "content_block_stop", "index": {current_block_index}}}\n\n'
                     current_block_index += 1
                     thinking_block_started = False
+                    thinking_signature = ""
 
                 # Close any open text block
                 if content_block_started:
@@ -148,8 +158,25 @@ async def anthropic_streaming_wrapper(
 
             # Handle reasoning/thinking content (from OpenAI-style reasoning_content)
             reasoning_content = delta.get("reasoning_content")
+            thought_sig_from_delta = delta.get("thought_signature", "")
+
+            # Always capture signature if available (may come in later deltas)
+            if thought_sig_from_delta and not thinking_signature:
+                thinking_signature = thought_sig_from_delta
+
             if reasoning_content:
+                import logging
+                logging.getLogger("rotator_library").debug(
+                    f"[Anthropic Stream] Sending thinking ({len(reasoning_content)} chars), sig={bool(thinking_signature)}"
+                )
                 if not thinking_block_started:
+                    # Close any open text block before starting a new thinking block
+                    # This enables interleaved thinking (thinking after tool results)
+                    if content_block_started:
+                        yield f'event: content_block_stop\ndata: {{"type": "content_block_stop", "index": {current_block_index}}}\n\n'
+                        current_block_index += 1
+                        content_block_started = False
+
                     # Start a thinking content block
                     block_start = {
                         "type": "content_block_start",
@@ -172,9 +199,18 @@ async def anthropic_streaming_wrapper(
             if content:
                 # If we were in a thinking block, close it first
                 if thinking_block_started and not content_block_started:
+                    # Send signature_delta if we have a signature
+                    if thinking_signature:
+                        sig_delta = {
+                            "type": "content_block_delta",
+                            "index": current_block_index,
+                            "delta": {"type": "signature_delta", "signature": thinking_signature},
+                        }
+                        yield f"event: content_block_delta\ndata: {json.dumps(sig_delta)}\n\n"
                     yield f'event: content_block_stop\ndata: {{"type": "content_block_stop", "index": {current_block_index}}}\n\n'
                     current_block_index += 1
                     thinking_block_started = False
+                    thinking_signature = ""
 
                 if not content_block_started:
                     # Start a text content block
@@ -202,9 +238,18 @@ async def anthropic_streaming_wrapper(
                 if tc_index not in tool_calls_by_index:
                     # Close previous thinking block if open
                     if thinking_block_started:
+                        # Send signature_delta if we have a signature
+                        if thinking_signature:
+                            sig_delta = {
+                                "type": "content_block_delta",
+                                "index": current_block_index,
+                                "delta": {"type": "signature_delta", "signature": thinking_signature},
+                            }
+                            yield f"event: content_block_delta\ndata: {json.dumps(sig_delta)}\n\n"
                         yield f'event: content_block_stop\ndata: {{"type": "content_block_stop", "index": {current_block_index}}}\n\n'
                         current_block_index += 1
                         thinking_block_started = False
+                        thinking_signature = ""
 
                     # Close previous text block if open
                     if content_block_started:

src/rotator_library/anthropic_compat/translator.py

@@ -7,11 +7,14 @@
 """
 
 import json
+import logging
 import uuid
 from typing import Any, Dict, List, Optional, Union
 
 from .models import AnthropicMessagesRequest
 
+lib_logger = logging.getLogger("rotator_library")
+
 
 def anthropic_to_openai_messages(
     anthropic_messages: List[dict], system: Optional[Union[str, List[dict]]] = None
@@ -56,12 +59,35 @@ def anthropic_to_openai_messages(
             # Handle content blocks
             openai_content = []
             tool_calls = []
+            reasoning_content = ""
+            thought_signature = None
 
             for block in content:
                 if isinstance(block, dict):
                     block_type = block.get("type", "text")
 
-                    if block_type == "text":
+                    if block_type in ("thinking", "redacted_thinking"):
+                        if role != "assistant":
+                            continue
+                        if reasoning_content:
+                            reasoning_content += "\n"
+                        thinking_text = ""
+                        if block_type == "redacted_thinking":
+                            reasoning_content += "[redacted]"
+                            thinking_text = "[redacted]"
+                        else:
+                            thinking_text = block.get("thinking", "")
+                            if thinking_text:
+                                reasoning_content += thinking_text
+                        signature = block.get("signature")
+                        if signature:
+                            thought_signature = signature
+                        lib_logger.debug(
+                            f"[Translator] Found {block_type} block: "
+                            f"has_thinking={bool(thinking_text)}, "
+                            f"has_signature={bool(signature)}"
+                        )
+                    elif block_type == "text":
                         openai_content.append(
                             {"type": "text", "text": block.get("text", "")}
                         )
@@ -197,15 +223,42 @@ def anthropic_to_openai_messages(
                 else:
                     msg_dict["content"] = None
                 msg_dict["tool_calls"] = tool_calls
+                if reasoning_content:
+                    msg_dict["reasoning_content"] = reasoning_content
+                    if thought_signature:
+                        msg_dict["thought_signature"] = thought_signature
+                    lib_logger.debug(
+                        f"[Translator] Assistant msg with tool_calls: "
+                        f"reasoning={len(reasoning_content)} chars, has_sig={bool(thought_signature)}"
+                    )
                 openai_messages.append(msg_dict)
             elif openai_content:
                 # Check if it's just text or mixed content
                 if len(openai_content) == 1 and openai_content[0].get("type") == "text":
-                    openai_messages.append(
-                        {"role": role, "content": openai_content[0].get("text", "")}
-                    )
+                    msg_dict = {
+                        "role": role,
+                        "content": openai_content[0].get("text", ""),
+                    }
                 else:
-                    openai_messages.append({"role": role, "content": openai_content})
+                    msg_dict = {"role": role, "content": openai_content}
+                if reasoning_content:
+                    msg_dict["reasoning_content"] = reasoning_content
+                    if thought_signature:
+                        msg_dict["thought_signature"] = thought_signature
+                    lib_logger.debug(
+                        f"[Translator] Assistant msg with text: "
+                        f"reasoning={len(reasoning_content)} chars, has_sig={bool(thought_signature)}"
+                    )
+                openai_messages.append(msg_dict)
+            elif reasoning_content:
+                msg_dict = {"role": role, "content": "", "reasoning_content": reasoning_content}
+                if thought_signature:
+                    msg_dict["thought_signature"] = thought_signature
+                lib_logger.debug(
+                    f"[Translator] Assistant msg (reasoning only): "
+                    f"reasoning={len(reasoning_content)} chars, has_sig={bool(thought_signature)}"
+                )
+                openai_messages.append(msg_dict)
 
     return openai_messages