Found 5 files
src/agents/models/chatcmpl_converter.py
tests/test_openai_chatcompletions_converter.py
tests/test_anthropic_thinking_blocks.py
src/agents/models/openai_chatcompletions.py
src/agents/extensions/models/litellm_model.py

Found 4 files
src/agents/models/chatcmpl_converter.py
tests/test_anthropic_thinking_blocks.py
src/agents/models/chatcmpl_stream_handler.py
src/agents/extensions/models/litellm_model.py

     1→from __future__ import annotations
     2→
     3→import json
     4→from collections.abc import Iterable
     5→from typing import Any, Literal, cast
     6→
     7→from openai import NOT_GIVEN, NotGiven
     8→from openai.types.chat import (
     9→    ChatCompletionAssistantMessageParam,
    10→    ChatCompletionContentPartImageParam,
    11→    ChatCompletionContentPartParam,
    12→    ChatCompletionContentPartTextParam,
    13→    ChatCompletionDeveloperMessageParam,
    14→    ChatCompletionMessage,
    15→    ChatCompletionMessageFunctionToolCallParam,
    16→    ChatCompletionMessageParam,
    17→    ChatCompletionSystemMessageParam,
    18→    ChatCompletionToolChoiceOptionParam,
    19→    ChatCompletionToolMessageParam,
    20→    ChatCompletionUserMessageParam,
    21→)
    22→from openai.types.chat.chat_completion_content_part_param import File, FileFile
    23→from openai.types.chat.chat_completion_tool_param import ChatCompletionToolParam
    24→from openai.types.chat.completion_create_params import ResponseFormat
    25→from openai.types.responses import (
    26→    EasyInputMessageParam,
    27→    ResponseFileSearchToolCallParam,
    28→    ResponseFunctionToolCall,
    29→    ResponseFunctionToolCallParam,
    30→    ResponseInputContentParam,
    31→    ResponseInputFileParam,
    32→    ResponseInputImageParam,
    33→    ResponseInputTextParam,
    34→    ResponseOutputMessage,
    35→    ResponseOutputMessageParam,
    36→    ResponseOutputRefusal,
    37→    ResponseOutputText,
    38→    ResponseReasoningItem,
    39→    ResponseReasoningItemParam,
    40→)
    41→from openai.types.responses.response_input_param import FunctionCallOutput, ItemReference, Message
    42→from openai.types.responses.response_reasoning_item import Content, Summary
    43→
    44→from ..agent_output import AgentOutputSchemaBase
    45→from ..exceptions import AgentsException, UserError
    46→from ..handoffs import Handoff
    47→from ..items import TResponseInputItem, TResponseOutputItem
    48→from ..model_settings import MCPToolChoice
    49→from ..tool import FunctionTool, Tool
    50→from .fake_id import FAKE_RESPONSES_ID
    51→
    52→
    53→class Converter:
    54→    @classmethod
    55→    def convert_tool_choice(
    56→        cls, tool_choice: Literal["auto", "required", "none"] | str | MCPToolChoice | None
    57→    ) -> ChatCompletionToolChoiceOptionParam | NotGiven:
    58→        if tool_choice is None:
    59→            return NOT_GIVEN
    60→        elif isinstance(tool_choice, MCPToolChoice):
    61→            raise UserError("MCPToolChoice is not supported for Chat Completions models")
    62→        elif tool_choice == "auto":
    63→            return "auto"
    64→        elif tool_choice == "required":
    65→            return "required"
    66→        elif tool_choice == "none":
    67→            return "none"
    68→        else:
    69→            return {
    70→                "type": "function",
    71→                "function": {
    72→                    "name": tool_choice,
    73→                },
    74→            }
    75→
    76→    @classmethod
    77→    def convert_response_format(
    78→        cls, final_output_schema: AgentOutputSchemaBase | None
    79→    ) -> ResponseFormat | NotGiven:
    80→        if not final_output_schema or final_output_schema.is_plain_text():
    81→            return NOT_GIVEN
    82→
    83→        return {
    84→            "type": "json_schema",
    85→            "json_schema": {
    86→                "name": "final_output",
    87→                "strict": final_output_schema.is_strict_json_schema(),
    88→                "schema": final_output_schema.json_schema(),
    89→            },
    90→        }
    91→
    92→    @classmethod
    93→    def message_to_output_items(cls, message: ChatCompletionMessage) -> list[TResponseOutputItem]:
    94→        items: list[TResponseOutputItem] = []
    95→
    96→        # Check if message is agents.extentions.models.litellm_model.InternalChatCompletionMessage
    97→        # We can't actually import it here because litellm is an optional dependency
    98→        # So we use hasattr to check for reasoning_content and thinking_blocks
    99→        if hasattr(message, "reasoning_content") and message.reasoning_content:
   100→            reasoning_item = ResponseReasoningItem(
   101→                id=FAKE_RESPONSES_ID,
   102→                summary=[Summary(text=message.reasoning_content, type="summary_text")],
   103→                type="reasoning",
   104→            )
   105→
   106→            # Store thinking blocks for Anthropic compatibility
   107→            if hasattr(message, "thinking_blocks") and message.thinking_blocks:
   108→                # Store thinking text in content and signature in encrypted_content
   109→                reasoning_item.content = []
   110→                signatures: list[str] = []
   111→                for block in message.thinking_blocks:
   112→                    if isinstance(block, dict):
   113→                        thinking_text = block.get("thinking", "")
   114→                        if thinking_text:
   115→                            reasoning_item.content.append(
   116→                                Content(text=thinking_text, type="reasoning_text")
   117→                            )
   118→                        # Store the signature if present
   119→                        if signature := block.get("signature"):
   120→                            signatures.append(signature)
   121→
   122→                # Store the signatures in encrypted_content with newline delimiter
   123→                if signatures:
   124→                    reasoning_item.encrypted_content = "\n".join(signatures)
   125→
   126→            items.append(reasoning_item)
   127→
   128→        message_item = ResponseOutputMessage(
   129→            id=FAKE_RESPONSES_ID,
   130→            content=[],
   131→            role="assistant",
   132→            type="message",
   133→            status="completed",
   134→        )
   135→        if message.content:
   136→            message_item.content.append(
   137→                ResponseOutputText(text=message.content, type="output_text", annotations=[])
   138→            )
   139→        if message.refusal:
   140→            message_item.content.append(
   141→                ResponseOutputRefusal(refusal=message.refusal, type="refusal")
   142→            )
   143→        if message.audio:
   144→            raise AgentsException("Audio is not currently supported")
   145→
   146→        if message_item.content:
   147→            items.append(message_item)
   148→
   149→        if message.tool_calls:
   150→            for tool_call in message.tool_calls:
   151→                if tool_call.type == "function":
   152→                    items.append(
   153→                        ResponseFunctionToolCall(
   154→                            id=FAKE_RESPONSES_ID,
   155→                            call_id=tool_call.id,
   156→                            arguments=tool_call.function.arguments,
   157→                            name=tool_call.function.name,
   158→                            type="function_call",
   159→                        )
   160→                    )
   161→                elif tool_call.type == "custom":
   162→                    pass
   163→
   164→        return items
   165→
   166→    @classmethod
   167→    def maybe_easy_input_message(cls, item: Any) -> EasyInputMessageParam | None:
   168→        if not isinstance(item, dict):
   169→            return None
   170→
   171→        keys = item.keys()
   172→        # EasyInputMessageParam only has these two keys
   173→        if keys != {"content", "role"}:
   174→            return None
   175→
   176→        role = item.get("role", None)
   177→        if role not in ("user", "assistant", "system", "developer"):
   178→            return None
   179→
   180→        if "content" not in item:
   181→            return None
   182→
   183→        return cast(EasyInputMessageParam, item)
   184→
   185→    @classmethod
   186→    def maybe_input_message(cls, item: Any) -> Message | None:
   187→        if (
   188→            isinstance(item, dict)
   189→            and item.get("type") == "message"
   190→            and item.get("role")
   191→            in (
   192→                "user",
   193→                "system",
   194→                "developer",
   195→            )
   196→        ):
   197→            return cast(Message, item)
   198→
   199→        return None
   200→
   201→    @classmethod
   202→    def maybe_file_search_call(cls, item: Any) -> ResponseFileSearchToolCallParam | None:
   203→        if isinstance(item, dict) and item.get("type") == "file_search_call":
   204→            return cast(ResponseFileSearchToolCallParam, item)
   205→        return None
   206→
   207→    @classmethod
   208→    def maybe_function_tool_call(cls, item: Any) -> ResponseFunctionToolCallParam | None:
   209→        if isinstance(item, dict) and item.get("type") == "function_call":
   210→            return cast(ResponseFunctionToolCallParam, item)
   211→        return None
   212→
   213→    @classmethod
   214→    def maybe_function_tool_call_output(
   215→        cls,
   216→        item: Any,
   217→    ) -> FunctionCallOutput | None:
   218→        if isinstance(item, dict) and item.get("type") == "function_call_output":
   219→            return cast(FunctionCallOutput, item)
   220→        return None
   221→
   222→    @classmethod
   223→    def maybe_item_reference(cls, item: Any) -> ItemReference | None:
   224→        if isinstance(item, dict) and item.get("type") == "item_reference":
   225→            return cast(ItemReference, item)
   226→        return None
   227→
   228→    @classmethod
   229→    def maybe_response_output_message(cls, item: Any) -> ResponseOutputMessageParam | None:
   230→        # ResponseOutputMessage is only used for messages with role assistant
   231→        if (
   232→            isinstance(item, dict)
   233→            and item.get("type") == "message"
   234→            and item.get("role") == "assistant"
   235→        ):
   236→            return cast(ResponseOutputMessageParam, item)
   237→        return None
   238→
   239→    @classmethod
   240→    def maybe_reasoning_message(cls, item: Any) -> ResponseReasoningItemParam | None:
   241→        if isinstance(item, dict) and item.get("type") == "reasoning":
   242→            return cast(ResponseReasoningItemParam, item)
   243→        return None
   244→
   245→    @classmethod
   246→    def extract_text_content(
   247→        cls, content: str | Iterable[ResponseInputContentParam]
   248→    ) -> str | list[ChatCompletionContentPartTextParam]:
   249→        all_content = cls.extract_all_content(content)
   250→        if isinstance(all_content, str):
   251→            return all_content
   252→        out: list[ChatCompletionContentPartTextParam] = []
   253→        for c in all_content:
   254→            if c.get("type") == "text":
   255→                out.append(cast(ChatCompletionContentPartTextParam, c))
   256→        return out
   257→
   258→    @classmethod
   259→    def extract_all_content(
   260→        cls, content: str | Iterable[ResponseInputContentParam]
   261→    ) -> str | list[ChatCompletionContentPartParam]:
   262→        if isinstance(content, str):
   263→            return content
   264→        out: list[ChatCompletionContentPartParam] = []
   265→
   266→        for c in content:
   267→            if isinstance(c, dict) and c.get("type") == "input_text":
   268→                casted_text_param = cast(ResponseInputTextParam, c)
   269→                out.append(
   270→                    ChatCompletionContentPartTextParam(
   271→                        type="text",
   272→                        text=casted_text_param["text"],
   273→                    )
   274→                )
   275→            elif isinstance(c, dict) and c.get("type") == "input_image":
   276→                casted_image_param = cast(ResponseInputImageParam, c)
   277→                if "image_url" not in casted_image_param or not casted_image_param["image_url"]:
   278→                    raise UserError(
   279→                        f"Only image URLs are supported for input_image {casted_image_param}"
   280→                    )
   281→                out.append(
   282→                    ChatCompletionContentPartImageParam(
   283→                        type="image_url",
   284→                        image_url={
   285→                            "url": casted_image_param["image_url"],
   286→                            "detail": casted_image_param.get("detail", "auto"),
   287→                        },
   288→                    )
   289→                )
   290→            elif isinstance(c, dict) and c.get("type") == "input_file":
   291→                casted_file_param = cast(ResponseInputFileParam, c)
   292→                if "file_data" not in casted_file_param or not casted_file_param["file_data"]:
   293→                    raise UserError(
   294→                        f"Only file_data is supported for input_file {casted_file_param}"
   295→                    )
   296→                if "filename" not in casted_file_param or not casted_file_param["filename"]:
   297→                    raise UserError(f"filename must be provided for input_file {casted_file_param}")
   298→                out.append(
   299→                    File(
   300→                        type="file",
   301→                        file=FileFile(
   302→                            file_data=casted_file_param["file_data"],
   303→                            filename=casted_file_param["filename"],
   304→                        ),
   305→                    )
   306→                )
   307→            else:
   308→                raise UserError(f"Unknown content: {c}")
   309→        return out
   310→
   311→    @classmethod
   312→    def items_to_messages(
   313→        cls,
   314→        items: str | Iterable[TResponseInputItem],
   315→        preserve_thinking_blocks: bool = False,
   316→    ) -> list[ChatCompletionMessageParam]:
   317→        """
   318→        Convert a sequence of 'Item' objects into a list of ChatCompletionMessageParam.
   319→
   320→        Args:
   321→            items: A string or iterable of response input items to convert
   322→            preserve_thinking_blocks: Whether to preserve thinking blocks in tool calls
   323→                for reasoning models like Claude 4 Sonnet/Opus which support interleaved
   324→                thinking. When True, thinking blocks are reconstructed and included in
   325→                assistant messages with tool calls.
   326→
   327→        Rules:
   328→        - EasyInputMessage or InputMessage (role=user) => ChatCompletionUserMessageParam
   329→        - EasyInputMessage or InputMessage (role=system) => ChatCompletionSystemMessageParam
   330→        - EasyInputMessage or InputMessage (role=developer) => ChatCompletionDeveloperMessageParam
   331→        - InputMessage (role=assistant) => Start or flush a ChatCompletionAssistantMessageParam
   332→        - response_output_message => Also produces/flushes a ChatCompletionAssistantMessageParam
   333→        - tool calls get attached to the *current* assistant message, or create one if none.
   334→        - tool outputs => ChatCompletionToolMessageParam
   335→        """
   336→
   337→        if isinstance(items, str):
   338→            return [
   339→                ChatCompletionUserMessageParam(
   340→                    role="user",
   341→                    content=items,
   342→                )
   343→            ]
   344→
   345→        result: list[ChatCompletionMessageParam] = []
   346→        current_assistant_msg: ChatCompletionAssistantMessageParam | None = None
   347→        pending_thinking_blocks: list[dict[str, str]] | None = None
   348→
   349→        def flush_assistant_message() -> None:
   350→            nonlocal current_assistant_msg
   351→            if current_assistant_msg is not None:
   352→                # The API doesn't support empty arrays for tool_calls
   353→                if not current_assistant_msg.get("tool_calls"):
   354→                    del current_assistant_msg["tool_calls"]
   355→                result.append(current_assistant_msg)
   356→                current_assistant_msg = None
   357→
   358→        def ensure_assistant_message() -> ChatCompletionAssistantMessageParam:
   359→            nonlocal current_assistant_msg, pending_thinking_blocks
   360→            if current_assistant_msg is None:
   361→                current_assistant_msg = ChatCompletionAssistantMessageParam(role="assistant")
   362→                current_assistant_msg["tool_calls"] = []
   363→
   364→            return current_assistant_msg
   365→
   366→        for item in items:
   367→            # 1) Check easy input message
   368→            if easy_msg := cls.maybe_easy_input_message(item):
   369→                role = easy_msg["role"]
   370→                content = easy_msg["content"]
   371→
   372→                if role == "user":
   373→                    flush_assistant_message()
   374→                    msg_user: ChatCompletionUserMessageParam = {
   375→                        "role": "user",
   376→                        "content": cls.extract_all_content(content),
   377→                    }
   378→                    result.append(msg_user)
   379→                elif role == "system":
   380→                    flush_assistant_message()
   381→                    msg_system: ChatCompletionSystemMessageParam = {
   382→                        "role": "system",
   383→                        "content": cls.extract_text_content(content),
   384→                    }
   385→                    result.append(msg_system)
   386→                elif role == "developer":
   387→                    flush_assistant_message()
   388→                    msg_developer: ChatCompletionDeveloperMessageParam = {
   389→                        "role": "developer",
   390→                        "content": cls.extract_text_content(content),
   391→                    }
   392→                    result.append(msg_developer)
   393→                elif role == "assistant":
   394→                    flush_assistant_message()
   395→                    msg_assistant: ChatCompletionAssistantMessageParam = {
   396→                        "role": "assistant",
   397→                        "content": cls.extract_text_content(content),
   398→                    }
   399→                    result.append(msg_assistant)
   400→                else:
   401→                    raise UserError(f"Unexpected role in easy_input_message: {role}")
   402→
   403→            # 2) Check input message
   404→            elif in_msg := cls.maybe_input_message(item):
   405→                role = in_msg["role"]
   406→                content = in_msg["content"]
   407→                flush_assistant_message()
   408→
   409→                if role == "user":
   410→                    msg_user = {
   411→                        "role": "user",
   412→                        "content": cls.extract_all_content(content),
   413→                    }
   414→                    result.append(msg_user)
   415→                elif role == "system":
   416→                    msg_system = {
   417→                        "role": "system",
   418→                        "content": cls.extract_text_content(content),
   419→                    }
   420→                    result.append(msg_system)
   421→                elif role == "developer":
   422→                    msg_developer = {
   423→                        "role": "developer",
   424→                        "content": cls.extract_text_content(content),
   425→                    }
   426→                    result.append(msg_developer)
   427→                else:
   428→                    raise UserError(f"Unexpected role in input_message: {role}")
   429→
   430→            # 3) response output message => assistant
   431→            elif resp_msg := cls.maybe_response_output_message(item):
   432→                flush_assistant_message()
   433→                new_asst = ChatCompletionAssistantMessageParam(role="assistant")
   434→                contents = resp_msg["content"]
   435→
   436→                text_segments = []
   437→                for c in contents:
   438→                    if c["type"] == "output_text":
   439→                        text_segments.append(c["text"])
   440→                    elif c["type"] == "refusal":
   441→                        new_asst["refusal"] = c["refusal"]
   442→                    elif c["type"] == "output_audio":
   443→                        # Can't handle this, b/c chat completions expects an ID which we dont have
   444→                        raise UserError(
   445→                            f"Only audio IDs are supported for chat completions, but got: {c}"
   446→                        )
   447→                    else:
   448→                        raise UserError(f"Unknown content type in ResponseOutputMessage: {c}")
   449→
   450→                if text_segments:
   451→                    combined = "\n".join(text_segments)
   452→                    new_asst["content"] = combined
   453→
   454→                new_asst["tool_calls"] = []
   455→                current_assistant_msg = new_asst
   456→
   457→            # 4) function/file-search calls => attach to assistant
   458→            elif file_search := cls.maybe_file_search_call(item):
   459→                asst = ensure_assistant_message()
   460→                tool_calls = list(asst.get("tool_calls", []))
   461→                new_tool_call = ChatCompletionMessageFunctionToolCallParam(
   462→                    id=file_search["id"],
   463→                    type="function",
   464→                    function={
   465→                        "name": "file_search_call",
   466→                        "arguments": json.dumps(
   467→                            {
   468→                                "queries": file_search.get("queries", []),
   469→                                "status": file_search.get("status"),
   470→                            }
   471→                        ),
   472→                    },
   473→                )
   474→                tool_calls.append(new_tool_call)
   475→                asst["tool_calls"] = tool_calls
   476→
   477→            elif func_call := cls.maybe_function_tool_call(item):
   478→                asst = ensure_assistant_message()
   479→
   480→                # If we have pending thinking blocks, use them as the content
   481→                # This is required for Anthropic API tool calls with interleaved thinking
   482→                if pending_thinking_blocks:
   483→                    asst["content"] = pending_thinking_blocks  # type: ignore
   484→                    pending_thinking_blocks = None  # Clear after using
   485→
   486→                tool_calls = list(asst.get("tool_calls", []))
   487→                arguments = func_call["arguments"] if func_call["arguments"] else "{}"
   488→                new_tool_call = ChatCompletionMessageFunctionToolCallParam(
   489→                    id=func_call["call_id"],
   490→                    type="function",
   491→                    function={
   492→                        "name": func_call["name"],
   493→                        "arguments": arguments,
   494→                    },
   495→                )
   496→                tool_calls.append(new_tool_call)
   497→                asst["tool_calls"] = tool_calls
   498→            # 5) function call output => tool message
   499→            elif func_output := cls.maybe_function_tool_call_output(item):
   500→                flush_assistant_message()
   501→                msg: ChatCompletionToolMessageParam = {
   502→                    "role": "tool",
   503→                    "tool_call_id": func_output["call_id"],
   504→                    "content": func_output["output"],
   505→                }
   506→                result.append(msg)
   507→
   508→            # 6) item reference => handle or raise
   509→            elif item_ref := cls.maybe_item_reference(item):
   510→                raise UserError(
   511→                    f"Encountered an item_reference, which is not supported: {item_ref}"
   512→                )
   513→
   514→            # 7) reasoning message => extract thinking blocks if present
   515→            elif reasoning_item := cls.maybe_reasoning_message(item):
   516→                # Reconstruct thinking blocks from content (text) and encrypted_content (signature)
   517→                content_items = reasoning_item.get("content", [])
   518→                encrypted_content = reasoning_item.get("encrypted_content")
   519→                signatures = encrypted_content.split("\n") if encrypted_content else []
   520→
   521→                if content_items and preserve_thinking_blocks:
   522→                    # Reconstruct thinking blocks from content and signature
   523→                    pending_thinking_blocks = []
   524→                    for content_item in content_items:
   525→                        if (
   526→                            isinstance(content_item, dict)
   527→                            and content_item.get("type") == "reasoning_text"
   528→                        ):
   529→                            thinking_block = {
   530→                                "type": "thinking",
   531→                                "thinking": content_item.get("text", ""),
   532→                            }
   533→                            # Add signatures if available
   534→                            if signatures:
   535→                                thinking_block["signature"] = signatures.pop(0)
   536→                            pending_thinking_blocks.append(thinking_block)
   537→
   538→            # 8) If we haven't recognized it => fail or ignore
   539→            else:
   540→                raise UserError(f"Unhandled item type or structure: {item}")
   541→
   542→        flush_assistant_message()
   543→        return result
   544→
   545→    @classmethod
   546→    def tool_to_openai(cls, tool: Tool) -> ChatCompletionToolParam:
   547→        if isinstance(tool, FunctionTool):
   548→            return {
   549→                "type": "function",
   550→                "function": {
   551→                    "name": tool.name,
   552→                    "description": tool.description or "",
   553→                    "parameters": tool.params_json_schema,
   554→                },
   555→            }
   556→
   557→        raise UserError(
   558→            f"Hosted tools are not supported with the ChatCompletions API. Got tool type: "
   559→            f"{type(tool)}, tool: {tool}"
   560→        )
   561→
   562→    @classmethod
   563→    def convert_handoff_tool(cls, handoff: Handoff[Any, Any]) -> ChatCompletionToolParam:
   564→        return {
   565→            "type": "function",
   566→            "function": {
   567→                "name": handoff.tool_name,
   568→                "description": handoff.tool_description,
   569→                "parameters": handoff.input_json_schema,
   570→            },
   571→        }
   572→

     1→"""
     2→Test for Anthropic thinking blocks in conversation history.
     3→
     4→This test validates the fix for issue #1704:
     5→- Thinking blocks are properly preserved from Anthropic responses
     6→- Reasoning items are stored in session but not sent back in conversation history
     7→- Non-reasoning models are unaffected
     8→- Token usage is not increased for non-reasoning scenarios
     9→"""
    10→
    11→from __future__ import annotations
    12→
    13→from typing import Any, cast
    14→
    15→from openai.types.chat import ChatCompletionMessageToolCall
    16→from openai.types.chat.chat_completion_message_tool_call import Function
    17→
    18→from agents.extensions.models.litellm_model import InternalChatCompletionMessage
    19→from agents.models.chatcmpl_converter import Converter
    20→
    21→
    22→def create_mock_anthropic_response_with_thinking() -> InternalChatCompletionMessage:
    23→    """Create a mock Anthropic response with thinking blocks (like real response)."""
    24→    message = InternalChatCompletionMessage(
    25→        role="assistant",
    26→        content="I'll check the weather in Paris for you.",
    27→        reasoning_content="I need to call the weather function for Paris",
    28→        thinking_blocks=[
    29→            {
    30→                "type": "thinking",
    31→                "thinking": "I need to call the weather function for Paris",
    32→                "signature": "EqMDCkYIBxgCKkBAFZO8EyZwN1hiLctq0YjZnP0KeKgprr+C0PzgDv4GSggnFwrPQHIZ9A5s+paH+DrQBI1+Vnfq3mLAU5lJnoetEgzUEWx/Cv1022ieAvcaDCXdmg1XkMK0tZ8uCCIwURYAAX0uf2wFdnWt9n8whkhmy8ARQD5G2za4R8X5vTqBq8jpJ15T3c1Jcf3noKMZKooCWFVf0/W5VQqpZTgwDkqyTau7XraS+u48YlmJGSfyWMPO8snFLMZLGaGmVJgHfEI5PILhOEuX/R2cEeLuC715f51LMVuxTNzlOUV/037JV6P2ten7D66FnWU9JJMMJJov+DjMb728yQFHwHz4roBJ5ePHaaFP6mDwpqYuG/hai6pVv2TAK1IdKUui/oXrYtU+0gxb6UF2kS1bspqDuN++R8JdL7CMSU5l28pQ8TsH1TpVF4jZpsFbp1Du4rQIULFsCFFg+Edf9tPgyKZOq6xcskIjT7oylAPO37/jhdNknDq2S82PaSKtke3ViOigtM5uJfG521ZscBJQ1K3kwoI/repIdV9PatjOYdsYAQ==",  # noqa: E501
    33→            }
    34→        ],
    35→    )
    36→    return message
    37→
    38→
    39→def test_converter_skips_reasoning_items():
    40→    """
    41→    Unit test to verify that reasoning items are skipped when converting items to messages.
    42→    """
    43→    # Create test items including a reasoning item
    44→    test_items: list[dict[str, Any]] = [
    45→        {"role": "user", "content": "Hello"},
    46→        {
    47→            "id": "reasoning_123",
    48→            "type": "reasoning",
    49→            "summary": [{"text": "User said hello", "type": "summary_text"}],
    50→        },
    51→        {
    52→            "id": "msg_123",
    53→            "type": "message",
    54→            "role": "assistant",
    55→            "content": [{"type": "output_text", "text": "Hi there!"}],
    56→            "status": "completed",
    57→        },
    58→    ]
    59→
    60→    # Convert to messages
    61→    messages = Converter.items_to_messages(test_items)  # type: ignore[arg-type]
    62→
    63→    # Should have user message and assistant message, but no reasoning content
    64→    assert len(messages) == 2
    65→    assert messages[0]["role"] == "user"
    66→    assert messages[1]["role"] == "assistant"
    67→
    68→    # Verify no thinking blocks in assistant message
    69→    assistant_msg = messages[1]
    70→    content = assistant_msg.get("content")
    71→    if isinstance(content, list):
    72→        for part in content:
    73→            assert part.get("type") != "thinking"
    74→
    75→
    76→def test_reasoning_items_preserved_in_message_conversion():
    77→    """
    78→    Test that reasoning content and thinking blocks are properly extracted
    79→    from Anthropic responses and stored in reasoning items.
    80→    """
    81→    # Create mock message with thinking blocks
    82→    mock_message = create_mock_anthropic_response_with_thinking()
    83→
    84→    # Convert to output items
    85→    output_items = Converter.message_to_output_items(mock_message)
    86→
    87→    # Should have reasoning item, message item, and tool call items
    88→    reasoning_items = [
    89→        item for item in output_items if hasattr(item, "type") and item.type == "reasoning"
    90→    ]
    91→    assert len(reasoning_items) == 1
    92→
    93→    reasoning_item = reasoning_items[0]
    94→    assert reasoning_item.summary[0].text == "I need to call the weather function for Paris"
    95→
    96→    # Verify thinking blocks are stored if we preserve them
    97→    if (
    98→        hasattr(reasoning_item, "content")
    99→        and reasoning_item.content
   100→        and len(reasoning_item.content) > 0
   101→    ):
   102→        thinking_block = reasoning_item.content[0]
   103→        assert thinking_block.type == "reasoning_text"
   104→        assert thinking_block.text == "I need to call the weather function for Paris"
   105→
   106→
   107→def test_anthropic_thinking_blocks_with_tool_calls():
   108→    """
   109→    Test for models with extended thinking and interleaved thinking with tool calls.
   110→
   111→    This test verifies the Anthropic's API's requirements for thinking blocks
   112→    to be the first content in assistant messages when reasoning is enabled and tool
   113→    calls are present.
   114→    """
   115→    # Create a message with reasoning, thinking blocks and tool calls
   116→    message = InternalChatCompletionMessage(
   117→        role="assistant",
   118→        content="I'll check the weather for you.",
   119→        reasoning_content="The user wants weather information, I need to call the weather function",
   120→        thinking_blocks=[
   121→            {
   122→                "type": "thinking",
   123→                "thinking": (
   124→                    "The user is asking about weather. "
   125→                    "Let me use the weather tool to get this information."
   126→                ),
   127→                "signature": "TestSignature123",
   128→            }
   129→        ],
   130→        tool_calls=[
   131→            ChatCompletionMessageToolCall(
   132→                id="call_123",
   133→                type="function",
   134→                function=Function(name="get_weather", arguments='{"city": "Tokyo"}'),
   135→            )
   136→        ],
   137→    )
   138→
   139→    # Step 1: Convert message to output items
   140→    output_items = Converter.message_to_output_items(message)
   141→
   142→    # Verify reasoning item exists and contains thinking blocks
   143→    reasoning_items = [
   144→        item for item in output_items if hasattr(item, "type") and item.type == "reasoning"
   145→    ]
   146→    assert len(reasoning_items) == 1, "Should have exactly one reasoning item"
   147→
   148→    reasoning_item = reasoning_items[0]
   149→
   150→    # Verify thinking text is stored in content
   151→    assert hasattr(reasoning_item, "content") and reasoning_item.content, (
   152→        "Reasoning item should have content"
   153→    )
   154→    assert reasoning_item.content[0].type == "reasoning_text", (
   155→        "Content should be reasoning_text type"
   156→    )
   157→
   158→    # Verify signature is stored in encrypted_content
   159→    assert hasattr(reasoning_item, "encrypted_content"), (
   160→        "Reasoning item should have encrypted_content"
   161→    )
   162→    assert reasoning_item.encrypted_content == "TestSignature123", "Signature should be preserved"
   163→
   164→    # Verify tool calls are present
   165→    tool_call_items = [
   166→        item for item in output_items if hasattr(item, "type") and item.type == "function_call"
   167→    ]
   168→    assert len(tool_call_items) == 1, "Should have exactly one tool call"
   169→
   170→    # Step 2: Convert output items back to messages
   171→    # Convert items to dicts for the converter (simulating serialization/deserialization)
   172→    items_as_dicts: list[dict[str, Any]] = []
   173→    for item in output_items:
   174→        if hasattr(item, "model_dump"):
   175→            items_as_dicts.append(item.model_dump())
   176→        else:
   177→            items_as_dicts.append(cast(dict[str, Any], item))
   178→
   179→    messages = Converter.items_to_messages(items_as_dicts, preserve_thinking_blocks=True)  # type: ignore[arg-type]
   180→
   181→    # Find the assistant message with tool calls
   182→    assistant_messages = [
   183→        msg for msg in messages if msg.get("role") == "assistant" and msg.get("tool_calls")
   184→    ]
   185→    assert len(assistant_messages) == 1, "Should have exactly one assistant message with tool calls"
   186→
   187→    assistant_msg = assistant_messages[0]
   188→
   189→    # Content must start with thinking blocks, not text
   190→    content = assistant_msg.get("content")
   191→    assert content is not None, "Assistant message should have content"
   192→
   193→    assert isinstance(content, list) and len(content) > 0, (
   194→        "Assistant message content should be a non-empty list"
   195→    )
   196→
   197→    first_content = content[0]
   198→    assert first_content.get("type") == "thinking", (
   199→        f"First content must be 'thinking' type for Anthropic compatibility, "
   200→        f"but got '{first_content.get('type')}'"
   201→    )
   202→    expected_thinking = (
   203→        "The user is asking about weather. Let me use the weather tool to get this information."
   204→    )
   205→    assert first_content.get("thinking") == expected_thinking, (
   206→        "Thinking content should be preserved"
   207→    )
   208→    # Signature should also be preserved
   209→    assert first_content.get("signature") == "TestSignature123", (
   210→        "Signature should be preserved in thinking block"
   211→    )
   212→
   213→    # Verify tool calls are preserved
   214→    tool_calls = assistant_msg.get("tool_calls", [])
   215→    assert len(cast(list[Any], tool_calls)) == 1, "Tool calls should be preserved"
   216→    assert cast(list[Any], tool_calls)[0]["function"]["name"] == "get_weather"
   217→

encrypted_content: sig-one
sig-two

a31955a fix #1750 better error message when passing AgentHooks to Runner (#1752)
a4c125e v0.3.1 (#1773)
10ceb8b Export `user_agent_override` contextmanager (#1768)
827af41 feat: add more options to Agent#as_tool function (#1751)
aed6359 feat: #1731 Enable developers to use Annotated types for function tool param description (#1753)
e486b3a Add warning for agent names that transform into conflicting function names (#1758)
76d637d fixl: #1668 Handoffs with gpt-5* model + store=False + remove_all_tools fails due to 404 error response (#1757)
bc949c3 docs: reformat run module docstrings to Google style for better mkdocstrings rendering (#1740)
85d7d5d Add encryption support using cryptography to Sessions implementation (#1674)
ee751cb feat(voice)!: migrate STT streaming to match GA Realtime API (#1759)
aeaf83f feat(realtime): #1560 add input audio noise reduction (#1749)
605611c feat: Support Anthropic extended thinking and interleaved thinking (#1744)
456d284 Fixed Race Condition in RunResultStreaming.stream_events() Method (#1745)
31ed091 docs: Fix tracing setup documentation (#1734)
4901770 Update all translated document pages (#1747)
d146551 docs: #1722 LiteLLM usage tracking (#1743)
c583dfc docs: add docstring for parameter session in run, run_sync and run_streamed functions (#1739)
efa88f7 Wait for input guardrails in streaming runs (#1730)
581111c fix: #1704 Preserve thinking blocks in Anthropic conversations with tool calls (#1706)
789575f fix(streaming): #1712 push processed_response.new_items (including HandoffCallItem) to event_queue (#1703)

Output items:
{'id': '__fake_id__', 'summary': [{'text': 'summary', 'type': 'summary_text'}], 'type': 'reasoning', 'content': [{'text': 'block one', 'type': 'reasoning_text'}, {'text': 'block two', 'type': 'reasoning_text'}], 'encrypted_content': 'sig-one\nsig-two', 'status': None}
{'id': '__fake_id__', 'content': [{'annotations': [], 'text': 'data', 'type': 'output_text', 'logprobs': None}], 'role': 'assistant', 'status': 'completed', 'type': 'message'}

Converted messages:
{'role': 'assistant', 'content': 'data'}

e47b47a fix(chatcmpl): preserve all LiteLLM thinking-block signatures in converter (#1779)

Exit code 128
fatal: unable to read 35446efe441071162b483dc9c15bcd10cd7aa884
commit e47b47af1b476767e611068ab2cc9a04ab6797fb
Author: Sung-jin Brian Hong <serialx@serialx.net>
Date:   Mon Sep 22 15:20:36 2025 +0900

    fix(chatcmpl): preserve all LiteLLM thinking-block signatures in converter (#1779)

  main

aa524e9 Update all translated document pages (#2044)
d515133 docs: Update document pages for v0.5.0 release (#2019)
69c3357 Docs: Add per-request usage to docs and example script (#2026)
92fcf51 v0.5.0 (#2015)
763048f Add Dapr session storage option (#1937)
465b45e fix(realtime): include tool arguments in RealtimeToolStart/RealtimeToolEnd events (#2028)
15ad038 fix(usage): Normalize None token details on Usage initialization (#2034)
10514ca fix: #2038 openai==2.7.0 compatibility (#2039)
d659a73 docs: clarify on_tool_start and on_tool_end hooks for local tools only (#2037)
0c4f2b9 fix: use ResponseOutputRefusal for refusal content part added event (#2013)

aa524e9 Update all translated document pages (#2044)
d515133 docs: Update document pages for v0.5.0 release (#2019)
69c3357 Docs: Add per-request usage to docs and example script (#2026)
92fcf51 v0.5.0 (#2015)
763048f Add Dapr session storage option (#1937)
465b45e fix(realtime): include tool arguments in RealtimeToolStart/RealtimeToolEnd events (#2028)
15ad038 fix(usage): Normalize None token details on Usage initialization (#2034)
10514ca fix: #2038 openai==2.7.0 compatibility (#2039)
d659a73 docs: clarify on_tool_start and on_tool_end hooks for local tools only (#2037)
0c4f2b9 fix: use ResponseOutputRefusal for refusal content part added event (#2013)
3b9368d feat: #1994 Add a list of per-request usage data to Usage  (#1995)
f91b38f fix: improve run_sync's python 3.14 compatibility (#2006)
be94419 feat: #1760 Add SIP support for realtime agent runner (#1993)
1466ddb Add Python 3.14 to the supported versions (#1961)
4ba2e8a docs: improve typing in lifecycle hook example code (#2002)
8f4c2cd docs: #1999 adjust the realtime module code comment (#2000)
a30c32e v0.4.2 (#1988)
59c3522 Fix #1559: Handle empty choices array in LiteLLM model (same as PR #935) (#1981)
8c4d4d0 fix: #1942 Enable async tool calling in Realtime sessions (#1984)
a714cf4 Fix: Add empty checks for reasoning content arrays in stream handler (#1982)
4bc33e3 ci: make format required (devs should run `make format` before committing) (#1979)
986eb7d fix: #1764 enable developers to pass custom reasoning effort for LiteLLM providers (#1972)
03dca68 make format
e1f2675 Add a link to PyPI project URL on README.md
fdcf6d3 v0.4.1 (#1963)
351104f Make Tool Output dict conversion stricter to improve backward compatibility (#1965)
648d14d Add engine accessor to SQLAlchemySession for closing it when it's created from a URL (#1960)
59a8b0f Fix streaming trace end before guardrails complete (#1921)
04eec50 Fix #1846 Litellm: fails with function name for tool_choice parameter w/ streaming enabled (#1971)
bacc65b fix: #1907 guardrails w/ turn_detection.interrupt_response: true (#1968)
1240562 Remove unused ui.py example file (#1967)
c422030 Tweak CI test job settings (#1962)
9db9c01 fix: prevent race condition in listener iteration (#1956)
e47a14f fix: await cancelled websocket task to prevent resource leak (#1955)
d1abf43 fix: Remove trailing commas causing tuple assignment in response cancellation (#1952)
2630489 fix: add missing mcp_approval_response event name (fixes #1020) (#1931)
00ec712 fix: prevent ValueError when audio buffer is empty in STT (fixes #821) (#1934)
53ec9d5 make format on main branch returns diff on some files (#1947)
cf1b933 Fix: call `_fix_tool_message_ordering` for all Anthropic models (#1936)
8dfac2a Update all translated document pages (#1933)
368734f docs: add missing items in side navi bar (ja, zh) (#1932)
748ac80 Update all translated document pages (#1922)
f78d0b5 Add breaking change notes in docs (#1894)
da32045 v0.4.0 (#1919)
886b9fc fix: #1916 openai_chatcompletions.Converter.extract_all_content does not support input_audio type items (#1918)
630cd37 fix: #1900 fix a bug where SQLAlchemySession could return items in an invalid order (#1917)
d9f1d5f Fixes realtime example app stability issues (#1905)
1a54ce7 Update all translated document pages (#1913)
2ccdbdf Document `AdvancedSQLiteSession` and refactor session docs (#1791)
3b7aed7 Add graceful cancel mode for streaming runs (#1896)

46d0d2f Fix extended thinking bug by reordering tool messages (#1798)
a425859 fix(chatcmpl): preserve text content when adding Anthropic thinking blocks to tool calls (#1784)
e47b47a fix(chatcmpl): preserve all LiteLLM thinking-block signatures in converter (#1779)

Exit code 128
fatal: unrecognized argument: --no-stat

Exit code 128
fatal: unable to read 35446efe441071162b483dc9c15bcd10cd7aa884
commit e47b47af1b476767e611068ab2cc9a04ab6797fb
Author: Sung-jin Brian Hong <serialx@serialx.net>
Date:   Mon Sep 22 15:20:36 2025 +0900

    fix(chatcmpl): preserve all LiteLLM thinking-block signatures in converter (#1779)

diff --git a/src/agents/models/chatcmpl_converter.py b/src/agents/models/chatcmpl_converter.py
index 96f02a5..0ece166 100644
--- a/src/agents/models/chatcmpl_converter.py
+++ b/src/agents/models/chatcmpl_converter.py
@@ -107,7 +107,7 @@ class Converter:
             if hasattr(message, "thinking_blocks") and message.thinking_blocks:
                 # Store thinking text in content and signature in encrypted_content
                 reasoning_item.content = []
-                signature = None
+                signatures: list[str] = []
                 for block in message.thinking_blocks:
                     if isinstance(block, dict):
                         thinking_text = block.get("thinking", "")
@@ -116,15 +116,12 @@ class Converter:
                                 Content(text=thinking_text, type="reasoning_text")
                             )
                         # Store the signature if present
-                        if block.get("signature"):
-                            signature = block.get("signature")
+                        if signature := block.get("signature"):
+                            signatures.append(signature)
 
-                # Store only the last signature in encrypted_content
-                # If there are multiple thinking blocks, this should be a problem.
-                # In practice, there should only be one signature for the entire reasoning step.
-                # Tested with: claude-sonnet-4-20250514
-                if signature:
-                    reasoning_item.encrypted_content = signature
+                # Store the signatures in encrypted_content with newline delimiter
+                if signatures:
+                    reasoning_item.encrypted_content = "\n".join(signatures)
 
             items.append(reasoning_item)
 
@@ -518,7 +515,8 @@ class Converter:
             elif reasoning_item := cls.maybe_reasoning_message(item):
                 # Reconstruct thinking blocks from content (text) and encrypted_content (signature)
                 content_items = reasoning_item.get("content", [])
-                signature = reasoning_item.get("encrypted_content")
+                encrypted_content = reasoning_item.get("encrypted_content")
+                signatures = encrypted_content.split("\n") if encrypted_content else []
 
                 if content_items and preserve_thinking_blocks:
                     # Reconstruct thinking blocks from content and signature
@@ -532,9 +530,9 @@ class Converter:
                                 "type": "thinking",
                                 "thinking": content_item.get("text", ""),
                             }
-                            # Add signature if available
-                            if signature:
-                                thinking_block["signature"] = signature
+                            # Add signatures if available
+                            if signatures:
+                                thinking_block["signature"] = signatures.pop(0)
                             pending_thinking_blocks.append(thinking_block)
 
             # 8) If we haven't recognized it => fail or ignore

(Bash completed with no output)

            # Store thinking blocks for Anthropic compatibility
            if hasattr(message, "thinking_blocks") and message.thinking_blocks:
                # Store thinking text in content and signature in encrypted_content
                reasoning_item.content = []
                signatures: list[str] = []
                for block in message.thinking_blocks:
                    if isinstance(block, dict):
                        thinking_text = block.get("thinking", "")
                        if thinking_text:
                            reasoning_item.content.append(
                                Content(text=thinking_text, type="reasoning_text")
                            )
                        # Store the signature if present
                        if signature := block.get("signature"):
                            signatures.append(signature)

                # Store the signatures in encrypted_content with newline delimiter
                if signatures:
                    reasoning_item.encrypted_content = "\n".join(signatures)

            items.append(reasoning_item)

        message_item = ResponseOutputMessage(
            id=FAKE_RESPONSES_ID,
            content=[],

            # Store thinking blocks for Anthropic compatibility
            if hasattr(message, "thinking_blocks") and message.thinking_blocks:
                # Store thinking text in content and signature in encrypted_content
                reasoning_item.content = []
                signatures: list[str] = []
                for block in message.thinking_blocks:
                    if isinstance(block, dict):
                        thinking_text = block.get("thinking", "")
                        if thinking_text:
                            reasoning_item.content.append(
                                Content(text=thinking_text, type="reasoning_text")
                            )
                        # Store the signature if present
                        if signature := block.get("signature"):
                            signatures.append(signature)

                # Store the signatures in encrypted_content with newline delimiter
                if signatures:
                    reasoning_item.encrypted_content = "\n".join(signatures)

            items.append(reasoning_item)

        message_item = ResponseOutputMessage(
            id=FAKE_RESPONSES_ID,
            content=[],

fatal: --ancestry-path given but there are no bottom commits

(Bash completed with no output)

Exit code 128
fatal: Cannot read blob 77ff22ee0e0fe26c854c25de32294f9bbf8aaa4e for path src/agents/models/chatcmpl_converter.py

a31955a fix #1750 better error message when passing AgentHooks to Runner (#1752)
605611c feat: Support Anthropic extended thinking and interleaved thinking (#1744)
efa88f7 Wait for input guardrails in streaming runs (#1730)
581111c fix: #1704 Preserve thinking blocks in Anthropic conversations with tool calls (#1706)
a4f7204 Fix a bug where Chat Completions model does not accept required "filename" parameter for "input_file" items (#1513)

fatal: unable to read 4369b342b83c163104a41bff54de9355991c3be8
commit 605611c54243dfa579f667dc2bcd3fa17c1b9b9f
Author: Sung-jin Brian Hong <serialx@serialx.net>
Date:   Tue Sep 16 17:36:29 2025 +0900

    feat: Support Anthropic extended thinking and interleaved thinking (#1744)

     1→from __future__ import annotations
     2→
     3→from collections.abc import AsyncIterator
     4→from dataclasses import dataclass, field
     5→
     6→from openai import AsyncStream
     7→from openai.types.chat import ChatCompletionChunk
     8→from openai.types.completion_usage import CompletionUsage
     9→from openai.types.responses import (
    10→    Response,
    11→    ResponseCompletedEvent,
    12→    ResponseContentPartAddedEvent,
    13→    ResponseContentPartDoneEvent,
    14→    ResponseCreatedEvent,
    15→    ResponseFunctionCallArgumentsDeltaEvent,
    16→    ResponseFunctionToolCall,
    17→    ResponseOutputItem,
    18→    ResponseOutputItemAddedEvent,
    19→    ResponseOutputItemDoneEvent,
    20→    ResponseOutputMessage,
    21→    ResponseOutputRefusal,
    22→    ResponseOutputText,
    23→    ResponseReasoningItem,
    24→    ResponseReasoningSummaryPartAddedEvent,
    25→    ResponseReasoningSummaryPartDoneEvent,
    26→    ResponseReasoningSummaryTextDeltaEvent,
    27→    ResponseRefusalDeltaEvent,
    28→    ResponseTextDeltaEvent,
    29→    ResponseUsage,
    30→)
    31→from openai.types.responses.response_reasoning_item import Content, Summary
    32→from openai.types.responses.response_reasoning_summary_part_added_event import (
    33→    Part as AddedEventPart,
    34→)
    35→from openai.types.responses.response_reasoning_summary_part_done_event import Part as DoneEventPart
    36→from openai.types.responses.response_reasoning_text_delta_event import (
    37→    ResponseReasoningTextDeltaEvent,
    38→)
    39→from openai.types.responses.response_reasoning_text_done_event import (
    40→    ResponseReasoningTextDoneEvent,
    41→)
    42→from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
    43→
    44→from ..items import TResponseStreamEvent
    45→from .fake_id import FAKE_RESPONSES_ID
    46→
    47→
    48→# Define a Part class for internal use
    49→class Part:
    50→    def __init__(self, text: str, type: str):
    51→        self.text = text
    52→        self.type = type
    53→
    54→
    55→@dataclass
    56→class StreamingState:
    57→    started: bool = False
    58→    text_content_index_and_output: tuple[int, ResponseOutputText] | None = None
    59→    refusal_content_index_and_output: tuple[int, ResponseOutputRefusal] | None = None
    60→    reasoning_content_index_and_output: tuple[int, ResponseReasoningItem] | None = None
    61→    function_calls: dict[int, ResponseFunctionToolCall] = field(default_factory=dict)
    62→    # Fields for real-time function call streaming
    63→    function_call_streaming: dict[int, bool] = field(default_factory=dict)
    64→    function_call_output_idx: dict[int, int] = field(default_factory=dict)
    65→    # Store accumulated thinking text and signature for Anthropic compatibility
    66→    thinking_text: str = ""
    67→    thinking_signature: str | None = None
    68→
    69→
    70→class SequenceNumber:
    71→    def __init__(self):
    72→        self._sequence_number = 0
    73→
    74→    def get_and_increment(self) -> int:
    75→        num = self._sequence_number
    76→        self._sequence_number += 1
    77→        return num
    78→
    79→
    80→class ChatCmplStreamHandler:
    81→    @classmethod
    82→    async def handle_stream(
    83→        cls,
    84→        response: Response,
    85→        stream: AsyncStream[ChatCompletionChunk],
    86→    ) -> AsyncIterator[TResponseStreamEvent]:
    87→        usage: CompletionUsage | None = None
    88→        state = StreamingState()
    89→        sequence_number = SequenceNumber()
    90→        async for chunk in stream:
    91→            if not state.started:
    92→                state.started = True
    93→                yield ResponseCreatedEvent(
    94→                    response=response,
    95→                    type="response.created",
    96→                    sequence_number=sequence_number.get_and_increment(),
    97→                )
    98→
    99→            # This is always set by the OpenAI API, but not by others e.g. LiteLLM
   100→            usage = chunk.usage if hasattr(chunk, "usage") else None
   101→
   102→            if not chunk.choices or not chunk.choices[0].delta:
   103→                continue
   104→
   105→            delta = chunk.choices[0].delta
   106→
   107→            # Handle thinking blocks from Anthropic (for preserving signatures)
   108→            if hasattr(delta, "thinking_blocks") and delta.thinking_blocks:
   109→                for block in delta.thinking_blocks:
   110→                    if isinstance(block, dict):
   111→                        # Accumulate thinking text
   112→                        thinking_text = block.get("thinking", "")
   113→                        if thinking_text:
   114→                            state.thinking_text += thinking_text
   115→                        # Store signature if present
   116→                        signature = block.get("signature")
   117→                        if signature:
   118→                            state.thinking_signature = signature
   119→
   120→            # Handle reasoning content for reasoning summaries
   121→            if hasattr(delta, "reasoning_content"):
   122→                reasoning_content = delta.reasoning_content
   123→                if reasoning_content and not state.reasoning_content_index_and_output:
   124→                    state.reasoning_content_index_and_output = (
   125→                        0,
   126→                        ResponseReasoningItem(
   127→                            id=FAKE_RESPONSES_ID,
   128→                            summary=[Summary(text="", type="summary_text")],
   129→                            type="reasoning",
   130→                        ),
   131→                    )
   132→                    yield ResponseOutputItemAddedEvent(
   133→                        item=ResponseReasoningItem(
   134→                            id=FAKE_RESPONSES_ID,
   135→                            summary=[Summary(text="", type="summary_text")],
   136→                            type="reasoning",
   137→                        ),
   138→                        output_index=0,
   139→                        type="response.output_item.added",
   140→                        sequence_number=sequence_number.get_and_increment(),
   141→                    )
   142→
   143→                    yield ResponseReasoningSummaryPartAddedEvent(
   144→                        item_id=FAKE_RESPONSES_ID,
   145→                        output_index=0,
   146→                        summary_index=0,
   147→                        part=AddedEventPart(text="", type="summary_text"),
   148→                        type="response.reasoning_summary_part.added",
   149→                        sequence_number=sequence_number.get_and_increment(),
   150→                    )
   151→
   152→                if reasoning_content and state.reasoning_content_index_and_output:
   153→                    yield ResponseReasoningSummaryTextDeltaEvent(
   154→                        delta=reasoning_content,
   155→                        item_id=FAKE_RESPONSES_ID,
   156→                        output_index=0,
   157→                        summary_index=0,
   158→                        type="response.reasoning_summary_text.delta",
   159→                        sequence_number=sequence_number.get_and_increment(),
   160→                    )
   161→
   162→                    # Create a new summary with updated text
   163→                    current_content = state.reasoning_content_index_and_output[1].summary[0]
   164→                    updated_text = current_content.text + reasoning_content
   165→                    new_content = Summary(text=updated_text, type="summary_text")
   166→                    state.reasoning_content_index_and_output[1].summary[0] = new_content
   167→
   168→            # Handle reasoning content from 3rd party platforms
   169→            if hasattr(delta, "reasoning"):
   170→                reasoning_text = delta.reasoning
   171→                if reasoning_text and not state.reasoning_content_index_and_output:
   172→                    state.reasoning_content_index_and_output = (
   173→                        0,
   174→                        ResponseReasoningItem(
   175→                            id=FAKE_RESPONSES_ID,
   176→                            summary=[],
   177→                            content=[Content(text="", type="reasoning_text")],
   178→                            type="reasoning",
   179→                        ),
   180→                    )
   181→                    yield ResponseOutputItemAddedEvent(
   182→                        item=ResponseReasoningItem(
   183→                            id=FAKE_RESPONSES_ID,
   184→                            summary=[],
   185→                            content=[Content(text="", type="reasoning_text")],
   186→                            type="reasoning",
   187→                        ),
   188→                        output_index=0,
   189→                        type="response.output_item.added",
   190→                        sequence_number=sequence_number.get_and_increment(),
   191→                    )
   192→
   193→                if reasoning_text and state.reasoning_content_index_and_output:
   194→                    yield ResponseReasoningTextDeltaEvent(
   195→                        delta=reasoning_text,
   196→                        item_id=FAKE_RESPONSES_ID,
   197→                        output_index=0,
   198→                        content_index=0,
   199→                        type="response.reasoning_text.delta",
   200→                        sequence_number=sequence_number.get_and_increment(),
   201→                    )
   202→
   203→                    # Create a new summary with updated text
   204→                    if state.reasoning_content_index_and_output[1].content is None:
   205→                        state.reasoning_content_index_and_output[1].content = [
   206→                            Content(text="", type="reasoning_text")
   207→                        ]
   208→                    current_text = state.reasoning_content_index_and_output[1].content[0]
   209→                    updated_text = current_text.text + reasoning_text
   210→                    new_text_content = Content(text=updated_text, type="reasoning_text")
   211→                    state.reasoning_content_index_and_output[1].content[0] = new_text_content
   212→
   213→            # Handle regular content
   214→            if delta.content is not None:
   215→                if not state.text_content_index_and_output:
   216→                    content_index = 0
   217→                    if state.reasoning_content_index_and_output:
   218→                        content_index += 1
   219→                    if state.refusal_content_index_and_output:
   220→                        content_index += 1
   221→
   222→                    state.text_content_index_and_output = (
   223→                        content_index,
   224→                        ResponseOutputText(
   225→                            text="",
   226→                            type="output_text",
   227→                            annotations=[],
   228→                        ),
   229→                    )
   230→                    # Start a new assistant message stream
   231→                    assistant_item = ResponseOutputMessage(
   232→                        id=FAKE_RESPONSES_ID,
   233→                        content=[],
   234→                        role="assistant",
   235→                        type="message",
   236→                        status="in_progress",
   237→                    )
   238→                    # Notify consumers of the start of a new output message + first content part
   239→                    yield ResponseOutputItemAddedEvent(
   240→                        item=assistant_item,
   241→                        output_index=state.reasoning_content_index_and_output
   242→                        is not None,  # fixed 0 -> 0 or 1
   243→                        type="response.output_item.added",
   244→                        sequence_number=sequence_number.get_and_increment(),
   245→                    )
   246→                    yield ResponseContentPartAddedEvent(
   247→                        content_index=state.text_content_index_and_output[0],
   248→                        item_id=FAKE_RESPONSES_ID,
   249→                        output_index=state.reasoning_content_index_and_output
   250→                        is not None,  # fixed 0 -> 0 or 1
   251→                        part=ResponseOutputText(
   252→                            text="",
   253→                            type="output_text",
   254→                            annotations=[],
   255→                        ),
   256→                        type="response.content_part.added",
   257→                        sequence_number=sequence_number.get_and_increment(),
   258→                    )
   259→                # Emit the delta for this segment of content
   260→                yield ResponseTextDeltaEvent(
   261→                    content_index=state.text_content_index_and_output[0],
   262→                    delta=delta.content,
   263→                    item_id=FAKE_RESPONSES_ID,
   264→                    output_index=state.reasoning_content_index_and_output
   265→                    is not None,  # fixed 0 -> 0 or 1
   266→                    type="response.output_text.delta",
   267→                    sequence_number=sequence_number.get_and_increment(),
   268→                    logprobs=[],
   269→                )
   270→                # Accumulate the text into the response part
   271→                state.text_content_index_and_output[1].text += delta.content
   272→
   273→            # Handle refusals (model declines to answer)
   274→            # This is always set by the OpenAI API, but not by others e.g. LiteLLM
   275→            if hasattr(delta, "refusal") and delta.refusal:
   276→                if not state.refusal_content_index_and_output:
   277→                    refusal_index = 0
   278→                    if state.reasoning_content_index_and_output:
   279→                        refusal_index += 1
   280→                    if state.text_content_index_and_output:
   281→                        refusal_index += 1
   282→
   283→                    state.refusal_content_index_and_output = (
   284→                        refusal_index,
   285→                        ResponseOutputRefusal(refusal="", type="refusal"),
   286→                    )
   287→                    # Start a new assistant message if one doesn't exist yet (in-progress)
   288→                    assistant_item = ResponseOutputMessage(
   289→                        id=FAKE_RESPONSES_ID,
   290→                        content=[],
   291→                        role="assistant",
   292→                        type="message",
   293→                        status="in_progress",
   294→                    )
   295→                    # Notify downstream that assistant message + first content part are starting
   296→                    yield ResponseOutputItemAddedEvent(
   297→                        item=assistant_item,
   298→                        output_index=state.reasoning_content_index_and_output
   299→                        is not None,  # fixed 0 -> 0 or 1
   300→                        type="response.output_item.added",
   301→                        sequence_number=sequence_number.get_and_increment(),
   302→                    )
   303→                    yield ResponseContentPartAddedEvent(
   304→                        content_index=state.refusal_content_index_and_output[0],
   305→                        item_id=FAKE_RESPONSES_ID,
   306→                        output_index=state.reasoning_content_index_and_output
   307→                        is not None,  # fixed 0 -> 0 or 1
   308→                        part=ResponseOutputText(
   309→                            text="",
   310→                            type="output_text",
   311→                            annotations=[],
   312→                        ),
   313→                        type="response.content_part.added",
   314→                        sequence_number=sequence_number.get_and_increment(),
   315→                    )
   316→                # Emit the delta for this segment of refusal
   317→                yield ResponseRefusalDeltaEvent(
   318→                    content_index=state.refusal_content_index_and_output[0],
   319→                    delta=delta.refusal,
   320→                    item_id=FAKE_RESPONSES_ID,
   321→                    output_index=state.reasoning_content_index_and_output
   322→                    is not None,  # fixed 0 -> 0 or 1
   323→                    type="response.refusal.delta",
   324→                    sequence_number=sequence_number.get_and_increment(),
   325→                )
   326→                # Accumulate the refusal string in the output part
   327→                state.refusal_content_index_and_output[1].refusal += delta.refusal
   328→
   329→            # Handle tool calls with real-time streaming support
   330→            if delta.tool_calls:
   331→                for tc_delta in delta.tool_calls:
   332→                    if tc_delta.index not in state.function_calls:
   333→                        state.function_calls[tc_delta.index] = ResponseFunctionToolCall(
   334→                            id=FAKE_RESPONSES_ID,
   335→                            arguments="",
   336→                            name="",
   337→                            type="function_call",
   338→                            call_id="",
   339→                        )
   340→                        state.function_call_streaming[tc_delta.index] = False
   341→
   342→                    tc_function = tc_delta.function
   343→
   344→                    # Accumulate arguments as they come in
   345→                    state.function_calls[tc_delta.index].arguments += (
   346→                        tc_function.arguments if tc_function else ""
   347→                    ) or ""
   348→
   349→                    # Set function name directly (it's correct from the first function call chunk)
   350→                    if tc_function and tc_function.name:
   351→                        state.function_calls[tc_delta.index].name = tc_function.name
   352→
   353→                    if tc_delta.id:
   354→                        state.function_calls[tc_delta.index].call_id = tc_delta.id
   355→
   356→                    function_call = state.function_calls[tc_delta.index]
   357→
   358→                    # Start streaming as soon as we have function name and call_id
   359→                    if (
   360→                        not state.function_call_streaming[tc_delta.index]
   361→                        and function_call.name
   362→                        and function_call.call_id
   363→                    ):
   364→                        # Calculate the output index for this function call
   365→                        function_call_starting_index = 0
   366→                        if state.reasoning_content_index_and_output:
   367→                            function_call_starting_index += 1
   368→                        if state.text_content_index_and_output:
   369→                            function_call_starting_index += 1
   370→                        if state.refusal_content_index_and_output:
   371→                            function_call_starting_index += 1
   372→
   373→                        # Add offset for already started function calls
   374→                        function_call_starting_index += sum(
   375→                            1 for streaming in state.function_call_streaming.values() if streaming
   376→                        )
   377→
   378→                        # Mark this function call as streaming and store its output index
   379→                        state.function_call_streaming[tc_delta.index] = True
   380→                        state.function_call_output_idx[tc_delta.index] = (
   381→                            function_call_starting_index
   382→                        )
   383→
   384→                        # Send initial function call added event
   385→                        yield ResponseOutputItemAddedEvent(
   386→                            item=ResponseFunctionToolCall(
   387→                                id=FAKE_RESPONSES_ID,
   388→                                call_id=function_call.call_id,
   389→                                arguments="",  # Start with empty arguments
   390→                                name=function_call.name,
   391→                                type="function_call",
   392→                            ),
   393→                            output_index=function_call_starting_index,
   394→                            type="response.output_item.added",
   395→                            sequence_number=sequence_number.get_and_increment(),
   396→                        )
   397→
   398→                    # Stream arguments if we've started streaming this function call
   399→                    if (
   400→                        state.function_call_streaming.get(tc_delta.index, False)
   401→                        and tc_function
   402→                        and tc_function.arguments
   403→                    ):
   404→                        output_index = state.function_call_output_idx[tc_delta.index]
   405→                        yield ResponseFunctionCallArgumentsDeltaEvent(
   406→                            delta=tc_function.arguments,
   407→                            item_id=FAKE_RESPONSES_ID,
   408→                            output_index=output_index,
   409→                            type="response.function_call_arguments.delta",
   410→                            sequence_number=sequence_number.get_and_increment(),
   411→                        )
   412→
   413→        if state.reasoning_content_index_and_output:
   414→            if (
   415→                state.reasoning_content_index_and_output[1].summary
   416→                and len(state.reasoning_content_index_and_output[1].summary) > 0
   417→            ):
   418→                yield ResponseReasoningSummaryPartDoneEvent(
   419→                    item_id=FAKE_RESPONSES_ID,
   420→                    output_index=0,
   421→                    summary_index=0,
   422→                    part=DoneEventPart(
   423→                        text=state.reasoning_content_index_and_output[1].summary[0].text,
   424→                        type="summary_text",
   425→                    ),
   426→                    type="response.reasoning_summary_part.done",
   427→                    sequence_number=sequence_number.get_and_increment(),
   428→                )
   429→            elif state.reasoning_content_index_and_output[1].content is not None:
   430→                yield ResponseReasoningTextDoneEvent(
   431→                    item_id=FAKE_RESPONSES_ID,
   432→                    output_index=0,
   433→                    content_index=0,
   434→                    text=state.reasoning_content_index_and_output[1].content[0].text,
   435→                    type="response.reasoning_text.done",
   436→                    sequence_number=sequence_number.get_and_increment(),
   437→                )
   438→            yield ResponseOutputItemDoneEvent(
   439→                item=state.reasoning_content_index_and_output[1],
   440→                output_index=0,
   441→                type="response.output_item.done",
   442→                sequence_number=sequence_number.get_and_increment(),
   443→            )
   444→
   445→        function_call_starting_index = 0
   446→        if state.reasoning_content_index_and_output:
   447→            function_call_starting_index += 1
   448→
   449→        if state.text_content_index_and_output:
   450→            function_call_starting_index += 1
   451→            # Send end event for this content part
   452→            yield ResponseContentPartDoneEvent(
   453→                content_index=state.text_content_index_and_output[0],
   454→                item_id=FAKE_RESPONSES_ID,
   455→                output_index=state.reasoning_content_index_and_output
   456→                is not None,  # fixed 0 -> 0 or 1
   457→                part=state.text_content_index_and_output[1],
   458→                type="response.content_part.done",
   459→                sequence_number=sequence_number.get_and_increment(),
   460→            )
   461→
   462→        if state.refusal_content_index_and_output:
   463→            function_call_starting_index += 1
   464→            # Send end event for this content part
   465→            yield ResponseContentPartDoneEvent(
   466→                content_index=state.refusal_content_index_and_output[0],
   467→                item_id=FAKE_RESPONSES_ID,
   468→                output_index=state.reasoning_content_index_and_output
   469→                is not None,  # fixed 0 -> 0 or 1
   470→                part=state.refusal_content_index_and_output[1],
   471→                type="response.content_part.done",
   472→                sequence_number=sequence_number.get_and_increment(),
   473→            )
   474→
   475→        # Send completion events for function calls
   476→        for index, function_call in state.function_calls.items():
   477→            if state.function_call_streaming.get(index, False):
   478→                # Function call was streamed, just send the completion event
   479→                output_index = state.function_call_output_idx[index]
   480→                yield ResponseOutputItemDoneEvent(
   481→                    item=ResponseFunctionToolCall(
   482→                        id=FAKE_RESPONSES_ID,
   483→                        call_id=function_call.call_id,
   484→                        arguments=function_call.arguments,
   485→                        name=function_call.name,
   486→                        type="function_call",
   487→                    ),
   488→                    output_index=output_index,
   489→                    type="response.output_item.done",
   490→                    sequence_number=sequence_number.get_and_increment(),
   491→                )
   492→            else:
   493→                # Function call was not streamed (fallback to old behavior)
   494→                # This handles edge cases where function name never arrived
   495→                fallback_starting_index = 0
   496→                if state.reasoning_content_index_and_output:
   497→                    fallback_starting_index += 1
   498→                if state.text_content_index_and_output:
   499→                    fallback_starting_index += 1
   500→                if state.refusal_content_index_and_output:
   501→                    fallback_starting_index += 1
   502→
   503→                # Add offset for already started function calls
   504→                fallback_starting_index += sum(
   505→                    1 for streaming in state.function_call_streaming.values() if streaming
   506→                )
   507→
   508→                # Send all events at once (backward compatibility)
   509→                yield ResponseOutputItemAddedEvent(
   510→                    item=ResponseFunctionToolCall(
   511→                        id=FAKE_RESPONSES_ID,
   512→                        call_id=function_call.call_id,
   513→                        arguments=function_call.arguments,
   514→                        name=function_call.name,
   515→                        type="function_call",
   516→                    ),
   517→                    output_index=fallback_starting_index,
   518→                    type="response.output_item.added",
   519→                    sequence_number=sequence_number.get_and_increment(),
   520→                )
   521→                yield ResponseFunctionCallArgumentsDeltaEvent(
   522→                    delta=function_call.arguments,
   523→                    item_id=FAKE_RESPONSES_ID,
   524→                    output_index=fallback_starting_index,
   525→                    type="response.function_call_arguments.delta",
   526→                    sequence_number=sequence_number.get_and_increment(),
   527→                )
   528→                yield ResponseOutputItemDoneEvent(
   529→                    item=ResponseFunctionToolCall(
   530→                        id=FAKE_RESPONSES_ID,
   531→                        call_id=function_call.call_id,
   532→                        arguments=function_call.arguments,
   533→                        name=function_call.name,
   534→                        type="function_call",
   535→                    ),
   536→                    output_index=fallback_starting_index,
   537→                    type="response.output_item.done",
   538→                    sequence_number=sequence_number.get_and_increment(),
   539→                )
   540→
   541→        # Finally, send the Response completed event
   542→        outputs: list[ResponseOutputItem] = []
   543→
   544→        # include Reasoning item if it exists
   545→        if state.reasoning_content_index_and_output:
   546→            reasoning_item = state.reasoning_content_index_and_output[1]
   547→            # Store thinking text in content and signature in encrypted_content
   548→            if state.thinking_text:
   549→                # Add thinking text as a Content object
   550→                if not reasoning_item.content:
   551→                    reasoning_item.content = []
   552→                reasoning_item.content.append(
   553→                    Content(text=state.thinking_text, type="reasoning_text")
   554→                )
   555→            # Store signature in encrypted_content
   556→            if state.thinking_signature:
   557→                reasoning_item.encrypted_content = state.thinking_signature
   558→            outputs.append(reasoning_item)
   559→
   560→        # include text or refusal content if they exist
   561→        if state.text_content_index_and_output or state.refusal_content_index_and_output:
   562→            assistant_msg = ResponseOutputMessage(
   563→                id=FAKE_RESPONSES_ID,
   564→                content=[],
   565→                role="assistant",
   566→                type="message",
   567→                status="completed",
   568→            )
   569→            if state.text_content_index_and_output:
   570→                assistant_msg.content.append(state.text_content_index_and_output[1])
   571→            if state.refusal_content_index_and_output:
   572→                assistant_msg.content.append(state.refusal_content_index_and_output[1])
   573→            outputs.append(assistant_msg)
   574→
   575→            # send a ResponseOutputItemDone for the assistant message
   576→            yield ResponseOutputItemDoneEvent(
   577→                item=assistant_msg,
   578→                output_index=state.reasoning_content_index_and_output
   579→                is not None,  # fixed 0 -> 0 or 1
   580→                type="response.output_item.done",
   581→                sequence_number=sequence_number.get_and_increment(),
   582→            )
   583→
   584→        for function_call in state.function_calls.values():
   585→            outputs.append(function_call)
   586→
   587→        final_response = response.model_copy()
   588→        final_response.output = outputs
   589→        final_response.usage = (
   590→            ResponseUsage(
   591→                input_tokens=usage.prompt_tokens or 0,
   592→                output_tokens=usage.completion_tokens or 0,
   593→                total_tokens=usage.total_tokens or 0,
   594→                output_tokens_details=OutputTokensDetails(
   595→                    reasoning_tokens=usage.completion_tokens_details.reasoning_tokens
   596→                    if usage.completion_tokens_details
   597→                    and usage.completion_tokens_details.reasoning_tokens
   598→                    else 0
   599→                ),
   600→                input_tokens_details=InputTokensDetails(
   601→                    cached_tokens=usage.prompt_tokens_details.cached_tokens
   602→                    if usage.prompt_tokens_details and usage.prompt_tokens_details.cached_tokens
   603→                    else 0
   604→                ),
   605→            )
   606→            if usage
   607→            else None
   608→        )
   609→
   610→        yield ResponseCompletedEvent(
   611→            response=final_response,
   612→            type="response.completed",
   613→            sequence_number=sequence_number.get_and_increment(),
   614→        )
   615→

The file /testbed/src/agents/models/chatcmpl_stream_handler.py has been updated successfully.

The file /testbed/src/agents/models/chatcmpl_stream_handler.py has been updated successfully.

The file /testbed/src/agents/models/chatcmpl_stream_handler.py has been updated successfully.

# Store accumulated thinking text and signatures for Anthropic compatibility
    thinking_text: str = ""
    thinking_signatures: list[str] = field(default_factory=list)


class SequenceNumber:
---
            # Handle thinking blocks from Anthropic (for preserving signatures)
            if hasattr(delta, "thinking_blocks") and delta.thinking_blocks:
                for block in delta.thinking_blocks:
                    if isinstance(block, dict):
                        # Accumulate thinking text
                        thinking_text = block.get("thinking", "")
                        if thinking_text:
                            state.thinking_text += thinking_text
                        # Store signature if present
                        signature = block.get("signature")
                        if signature:
                            state.thinking_signatures.append(signature)

            # Handle reasoning content for reasoning summaries
---
            # Store signatures in encrypted_content with newline delimiter
            if state.thinking_signatures:
                reasoning_item.encrypted_content = "\n".join(state.thinking_signatures)
            outputs.append(reasoning_item)

        # include text or refusal content if they exist

============================= test session starts ==============================
platform linux -- Python 3.12.12, pytest-8.4.1, pluggy-1.6.0 -- /project/testbed/.venv/bin/python
cachedir: .pytest_cache
rootdir: /testbed
configfile: pyproject.toml
plugins: asyncio-1.1.0, inline-snapshot-0.27.2, anyio-4.10.0, mock-3.14.1
asyncio: mode=Mode.AUTO, asyncio_default_fixture_loop_scope=session, asyncio_default_test_loop_scope=function
collecting ... collected 3 items

tests/test_anthropic_thinking_blocks.py::test_converter_skips_reasoning_items PASSED [ 33%]
tests/test_anthropic_thinking_blocks.py::test_reasoning_items_preserved_in_message_conversion PASSED [ 66%]
tests/test_anthropic_thinking_blocks.py::test_anthropic_thinking_blocks_with_tool_calls PASSED [100%]

============================== 3 passed in 1.62s ===============================

     1→"""
     2→Test for Anthropic thinking blocks in conversation history.
     3→
     4→This test validates the fix for issue #1704:
     5→- Thinking blocks are properly preserved from Anthropic responses
     6→- Reasoning items are stored in session but not sent back in conversation history
     7→- Non-reasoning models are unaffected
     8→- Token usage is not increased for non-reasoning scenarios
     9→"""
    10→
    11→from __future__ import annotations
    12→
    13→from typing import Any, cast
    14→
    15→from openai.types.chat import ChatCompletionMessageToolCall
    16→from openai.types.chat.chat_completion_message_tool_call import Function
    17→
    18→from agents.extensions.models.litellm_model import InternalChatCompletionMessage
    19→from agents.models.chatcmpl_converter import Converter
    20→
    21→
    22→def create_mock_anthropic_response_with_thinking() -> InternalChatCompletionMessage:
    23→    """Create a mock Anthropic response with thinking blocks (like real response)."""
    24→    message = InternalChatCompletionMessage(
    25→        role="assistant",
    26→        content="I'll check the weather in Paris for you.",
    27→        reasoning_content="I need to call the weather function for Paris",
    28→        thinking_blocks=[
    29→            {
    30→                "type": "thinking",
    31→                "thinking": "I need to call the weather function for Paris",
    32→                "signature": "EqMDCkYIBxgCKkBAFZO8EyZwN1hiLctq0YjZnP0KeKgprr+C0PzgDv4GSggnFwrPQHIZ9A5s+paH+DrQBI1+Vnfq3mLAU5lJnoetEgzUEWx/Cv1022ieAvcaDCXdmg1XkMK0tZ8uCCIwURYAAX0uf2wFdnWt9n8whkhmy8ARQD5G2za4R8X5vTqBq8jpJ15T3c1Jcf3noKMZKooCWFVf0/W5VQqpZTgwDkqyTau7XraS+u48YlmJGSfyWMPO8snFLMZLGaGmVJgHfEI5PILhOEuX/R2cEeLuC715f51LMVuxTNzlOUV/037JV6P2ten7D66FnWU9JJMMJJov+DjMb728yQFHwHz4roBJ5ePHaaFP6mDwpqYuG/hai6pVv2TAK1IdKUui/oXrYtU+0gxb6UF2kS1bspqDuN++R8JdL7CMSU5l28pQ8TsH1TpVF4jZpsFbp1Du4rQIULFsCFFg+Edf9tPgyKZOq6xcskIjT7oylAPO37/jhdNknDq2S82PaSKtke3ViOigtM5uJfG521ZscBJQ1K3kwoI/repIdV9PatjOYdsYAQ==",  # noqa: E501
    33→            }
    34→        ],
    35→    )
    36→    return message
    37→
    38→
    39→def test_converter_skips_reasoning_items():
    40→    """
    41→    Unit test to verify that reasoning items are skipped when converting items to messages.
    42→    """
    43→    # Create test items including a reasoning item
    44→    test_items: list[dict[str, Any]] = [
    45→        {"role": "user", "content": "Hello"},
    46→        {
    47→            "id": "reasoning_123",
    48→            "type": "reasoning",
    49→            "summary": [{"text": "User said hello", "type": "summary_text"}],
    50→        },
    51→        {
    52→            "id": "msg_123",
    53→            "type": "message",
    54→            "role": "assistant",
    55→            "content": [{"type": "output_text", "text": "Hi there!"}],
    56→            "status": "completed",
    57→        },
    58→    ]
    59→
    60→    # Convert to messages
    61→    messages = Converter.items_to_messages(test_items)  # type: ignore[arg-type]
    62→
    63→    # Should have user message and assistant message, but no reasoning content
    64→    assert len(messages) == 2
    65→    assert messages[0]["role"] == "user"
    66→    assert messages[1]["role"] == "assistant"
    67→
    68→    # Verify no thinking blocks in assistant message
    69→    assistant_msg = messages[1]
    70→    content = assistant_msg.get("content")
    71→    if isinstance(content, list):
    72→        for part in content:
    73→            assert part.get("type") != "thinking"
    74→
    75→
    76→def test_reasoning_items_preserved_in_message_conversion():
    77→    """
    78→    Test that reasoning content and thinking blocks are properly extracted
    79→    from Anthropic responses and stored in reasoning items.
    80→    """
    81→    # Create mock message with thinking blocks
    82→    mock_message = create_mock_anthropic_response_with_thinking()
    83→
    84→    # Convert to output items
    85→    output_items = Converter.message_to_output_items(mock_message)
    86→
    87→    # Should have reasoning item, message item, and tool call items
    88→    reasoning_items = [
    89→        item for item in output_items if hasattr(item, "type") and item.type == "reasoning"
    90→    ]
    91→    assert len(reasoning_items) == 1
    92→
    93→    reasoning_item = reasoning_items[0]
    94→    assert reasoning_item.summary[0].text == "I need to call the weather function for Paris"
    95→
    96→    # Verify thinking blocks are stored if we preserve them
    97→    if (
    98→        hasattr(reasoning_item, "content")
    99→        and reasoning_item.content
   100→        and len(reasoning_item.content) > 0
   101→    ):
   102→        thinking_block = reasoning_item.content[0]
   103→        assert thinking_block.type == "reasoning_text"
   104→        assert thinking_block.text == "I need to call the weather function for Paris"
   105→
   106→
   107→def test_anthropic_thinking_blocks_with_tool_calls():
   108→    """
   109→    Test for models with extended thinking and interleaved thinking with tool calls.
   110→
   111→    This test verifies the Anthropic's API's requirements for thinking blocks
   112→    to be the first content in assistant messages when reasoning is enabled and tool
   113→    calls are present.
   114→    """
   115→    # Create a message with reasoning, thinking blocks and tool calls
   116→    message = InternalChatCompletionMessage(
   117→        role="assistant",
   118→        content="I'll check the weather for you.",
   119→        reasoning_content="The user wants weather information, I need to call the weather function",
   120→        thinking_blocks=[
   121→            {
   122→                "type": "thinking",
   123→                "thinking": (
   124→                    "The user is asking about weather. "
   125→                    "Let me use the weather tool to get this information."
   126→                ),
   127→                "signature": "TestSignature123",
   128→            }
   129→        ],
   130→        tool_calls=[
   131→            ChatCompletionMessageToolCall(
   132→                id="call_123",
   133→                type="function",
   134→                function=Function(name="get_weather", arguments='{"city": "Tokyo"}'),
   135→            )
   136→        ],
   137→    )
   138→
   139→    # Step 1: Convert message to output items
   140→    output_items = Converter.message_to_output_items(message)
   141→
   142→    # Verify reasoning item exists and contains thinking blocks
   143→    reasoning_items = [
   144→        item for item in output_items if hasattr(item, "type") and item.type == "reasoning"
   145→    ]
   146→    assert len(reasoning_items) == 1, "Should have exactly one reasoning item"
   147→
   148→    reasoning_item = reasoning_items[0]
   149→
   150→    # Verify thinking text is stored in content
   151→    assert hasattr(reasoning_item, "content") and reasoning_item.content, (
   152→        "Reasoning item should have content"
   153→    )
   154→    assert reasoning_item.content[0].type == "reasoning_text", (
   155→        "Content should be reasoning_text type"
   156→    )
   157→
   158→    # Verify signature is stored in encrypted_content
   159→    assert hasattr(reasoning_item, "encrypted_content"), (
   160→        "Reasoning item should have encrypted_content"
   161→    )
   162→    assert reasoning_item.encrypted_content == "TestSignature123", "Signature should be preserved"
   163→
   164→    # Verify tool calls are present
   165→    tool_call_items = [
   166→        item for item in output_items if hasattr(item, "type") and item.type == "function_call"
   167→    ]
   168→    assert len(tool_call_items) == 1, "Should have exactly one tool call"
   169→
   170→    # Step 2: Convert output items back to messages
   171→    # Convert items to dicts for the converter (simulating serialization/deserialization)
   172→    items_as_dicts: list[dict[str, Any]] = []
   173→    for item in output_items:
   174→        if hasattr(item, "model_dump"):
   175→            items_as_dicts.append(item.model_dump())
   176→        else:
   177→            items_as_dicts.append(cast(dict[str, Any], item))
   178→
   179→    messages = Converter.items_to_messages(items_as_dicts, preserve_thinking_blocks=True)  # type: ignore[arg-type]
   180→
   181→    # Find the assistant message with tool calls
   182→    assistant_messages = [
   183→        msg for msg in messages if msg.get("role") == "assistant" and msg.get("tool_calls")
   184→    ]
   185→    assert len(assistant_messages) == 1, "Should have exactly one assistant message with tool calls"
   186→
   187→    assistant_msg = assistant_messages[0]
   188→
   189→    # Content must start with thinking blocks, not text
   190→    content = assistant_msg.get("content")
   191→    assert content is not None, "Assistant message should have content"
   192→
   193→    assert isinstance(content, list) and len(content) > 0, (
   194→        "Assistant message content should be a non-empty list"
   195→    )
   196→
   197→    first_content = content[0]
   198→    assert first_content.get("type") == "thinking", (
   199→        f"First content must be 'thinking' type for Anthropic compatibility, "
   200→        f"but got '{first_content.get('type')}'"
   201→    )
   202→    expected_thinking = (
   203→        "The user is asking about weather. Let me use the weather tool to get this information."
   204→    )
   205→    assert first_content.get("thinking") == expected_thinking, (
   206→        "Thinking content should be preserved"
   207→    )
   208→    # Signature should also be preserved
   209→    assert first_content.get("signature") == "TestSignature123", (
   210→        "Signature should be preserved in thinking block"
   211→    )
   212→
   213→    # Verify tool calls are preserved
   214→    tool_calls = assistant_msg.get("tool_calls", [])
   215→    assert len(cast(list[Any], tool_calls)) == 1, "Tool calls should be preserved"
   216→    assert cast(list[Any], tool_calls)[0]["function"]["name"] == "get_weather"
   217→

The file /testbed/tests/test_anthropic_thinking_blocks.py has been updated successfully.

        # Step 2: Convert output items back to messages and verify round-trip
        items_as_dicts: list[dict[str, Any]] = []
        for item in output_items:
            if hasattr(item, "model_dump"):
                items_as_dicts.append(item.model_dump())
            else:
                items_as_dicts.append(cast(dict[str, Any], item))
    
        messages = Converter.items_to_messages(items_as_dicts, preserve_thinking_blocks=True)  # type: ignore[arg-type]
    
        # Find the assistant message
        assistant_messages = [msg for msg in messages if msg.get("role") == "assistant"]
        assert len(assistant_messages) == 1, "Should have exactly one assistant message"
    
        assistant_msg = assistant_messages[0]
        content = assistant_msg.get("content")
    
        # Verify thinking blocks are reconstructed with correct signatures
>       assert isinstance(content, list) and len(content) == 3, (
            "Should have three reconstructed thinking blocks"
        )
E       AssertionError: Should have three reconstructed thinking blocks
E       assert (False)
E        +  where False = isinstance('Here is my response.', list)

tests/test_anthropic_thinking_blocks.py:296: AssertionError
=========================== short test summary info ============================
FAILED tests/test_anthropic_thinking_blocks.py::test_multiple_thinking_blocks_preserve_all_signatures
========================= 1 failed, 3 passed in 1.96s ==========================

The file /testbed/tests/test_anthropic_thinking_blocks.py has been updated successfully.

============================= test session starts ==============================
platform linux -- Python 3.12.12, pytest-8.4.1, pluggy-1.6.0 -- /project/testbed/.venv/bin/python
cachedir: .pytest_cache
rootdir: /testbed
configfile: pyproject.toml
plugins: asyncio-1.1.0, inline-snapshot-0.27.2, anyio-4.10.0, mock-3.14.1
asyncio: mode=Mode.AUTO, asyncio_default_fixture_loop_scope=session, asyncio_default_test_loop_scope=function
collecting ... collected 4 items

tests/test_anthropic_thinking_blocks.py::test_converter_skips_reasoning_items PASSED [ 25%]
tests/test_anthropic_thinking_blocks.py::test_reasoning_items_preserved_in_message_conversion PASSED [ 50%]
tests/test_anthropic_thinking_blocks.py::test_anthropic_thinking_blocks_with_tool_calls PASSED [ 75%]
tests/test_anthropic_thinking_blocks.py::test_multiple_thinking_blocks_preserve_all_signatures PASSED [100%]

============================== 4 passed in 1.59s ===============================

============================= test session starts ==============================
platform linux -- Python 3.12.12, pytest-8.4.1, pluggy-1.6.0 -- /project/testbed/.venv/bin/python
cachedir: .pytest_cache
rootdir: /testbed
configfile: pyproject.toml
plugins: asyncio-1.1.0, inline-snapshot-0.27.2, anyio-4.10.0, mock-3.14.1
asyncio: mode=Mode.AUTO, asyncio_default_fixture_loop_scope=session, asyncio_default_test_loop_scope=function
collecting ... collected 19 items

tests/test_openai_chatcompletions_converter.py::test_message_to_output_items_with_text_only PASSED [  5%]
tests/test_openai_chatcompletions_converter.py::test_message_to_output_items_with_refusal PASSED [ 10%]
tests/test_openai_chatcompletions_converter.py::test_message_to_output_items_with_tool_call PASSED [ 15%]
tests/test_openai_chatcompletions_converter.py::test_items_to_messages_with_string_user_content PASSED [ 21%]
tests/test_openai_chatcompletions_converter.py::test_items_to_messages_with_easy_input_message PASSED [ 26%]
tests/test_openai_chatcompletions_converter.py::test_items_to_messages_with_output_message_and_function_call PASSED [ 31%]
tests/test_openai_chatcompletions_converter.py::test_convert_tool_choice_handles_standard_and_named_options PASSED [ 36%]
tests/test_openai_chatcompletions_converter.py::test_convert_response_format_returns_not_given_for_plain_text_and_dict_for_schemas PASSED [ 42%]
tests/test_openai_chatcompletions_converter.py::test_items_to_messages_with_function_output_item PASSED [ 47%]
tests/test_openai_chatcompletions_converter.py::test_extract_all_and_text_content_for_strings_and_lists PASSED [ 52%]
tests/test_openai_chatcompletions_converter.py::test_items_to_messages_handles_system_and_developer_roles PASSED [ 57%]
tests/test_openai_chatcompletions_converter.py::test_maybe_input_message_allows_message_typed_dict PASSED [ 63%]
tests/test_openai_chatcompletions_converter.py::test_tool_call_conversion PASSED [ 68%]
tests/test_openai_chatcompletions_converter.py::test_input_message_with_all_roles[user] PASSED [ 73%]
tests/test_openai_chatcompletions_converter.py::test_input_message_with_all_roles[system] PASSED [ 78%]
tests/test_openai_chatcompletions_converter.py::test_input_message_with_all_roles[developer] PASSED [ 84%]
tests/test_openai_chatcompletions_converter.py::test_item_reference_errors PASSED [ 89%]
tests/test_openai_chatcompletions_converter.py::test_unknown_object_errors PASSED [ 94%]
tests/test_openai_chatcompletions_converter.py::test_assistant_messages_in_history PASSED [100%]

============================== 19 passed in 0.24s ==============================

encrypted_content: sig-one
sig-two

Expected: sig-one
sig-two
Actual:   sig-one
sig-two
Match: True

tests/test_function_tool.py ...........                                  [ 57%]
tests/test_function_tool_decorator.py ............                       [ 59%]
tests/test_global_hooks.py ....                                          [ 60%]
tests/test_guardrails.py ........                                        [ 61%]
tests/test_handoff_tool.py ..............                                [ 62%]
tests/test_items_helpers.py ................                             [ 64%]
tests/test_logprobs.py .                                                 [ 65%]
tests/test_max_turns.py ....                                             [ 65%]
tests/test_model_payload_iterators.py ..                                 [ 65%]
tests/test_openai_chatcompletions.py .........                           [ 67%]
tests/test_openai_chatcompletions_converter.py ...................       [ 69%]
tests/test_openai_chatcompletions_stream.py ....                         [ 70%]
tests/test_openai_responses.py ..                                        [ 70%]
tests/test_openai_responses_converter.py ....                            [ 70%]
tests/test_output_tool.py .........                                      [ 71%]
tests/test_pretty_print.py ......                                        [ 72%]
tests/test_reasoning_content.py ...                                      [ 73%]
tests/test_repl.py .                                                     [ 73%]
tests/test_responses_tracing.py ......                                   [ 74%]
tests/test_result_cast.py ...                                            [ 74%]
tests/test_run.py .                                                      [ 74%]
tests/test_run_config.py ................                                [ 76%]
tests/test_run_error_details.py ..                                       [ 76%]
tests/test_run_hooks.py ........                                         [ 77%]
tests/test_run_step_execution.py ...........                             [ 79%]
tests/test_run_step_processing.py ...............                        [ 81%]
tests/test_session.py .........................                          [ 84%]
tests/test_session_exceptions.py .......                                 [ 85%]
tests/test_stream_events.py ..                                           [ 85%]
tests/test_streaming_tool_call_arguments.py ....                         [ 86%]
tests/test_strict_schema.py ...........                                  [ 87%]
tests/test_tool_choice_reset.py ......                                   [ 88%]
tests/test_tool_converter.py ...                                         [ 88%]
tests/test_tool_use_behavior.py .......                                  [ 89%]
tests/test_trace_processor.py ..............                             [ 91%]
tests/test_tracing.py .............                                      [ 93%]
tests/test_tracing_errors.py ........                                    [ 94%]
tests/test_tracing_errors_streamed.py .........                          [ 95%]
tests/test_usage.py ..                                                   [ 95%]
tests/test_visualization.py .....                                        [ 96%]
tests/tracing/test_processor_api_key.py ..                               [ 96%]
tests/tracing/test_set_api_key_fix.py .                                  [ 96%]
tests/utils/test_json.py .                                               [ 96%]
tests/voice/test_input.py .......                                        [ 97%]
tests/voice/test_openai_stt.py ........                                  [ 98%]
tests/voice/test_openai_tts.py ..                                        [ 99%]
tests/voice/test_pipeline.py ......                                      [ 99%]
tests/voice/test_workflow.py .                                           [100%]

============================= 770 passed in 33.29s =============================