# Upstream code (simplified)
if "tool_calls" in message.additional_kwargs:
    message_dicts = [tc.model_dump() for tc in message.additional_kwargs["tool_calls"]]
    return [*reasoning, *message_dicts]          # <-- text content is lost
elif tool_calls:
    return [*reasoning, *tool_calls]             # <-- same here

from llama_index.core.base.llms.types import ChatMessage, MessageRole, TextBlock, ToolCallBlock
from llama_index.llms.openai.utils import to_openai_responses_message_dict

msg = ChatMessage(
    role=MessageRole.ASSISTANT,
    blocks=[
        TextBlock(text="I'll search for that information now."),
        ToolCallBlock(tool_name="search", tool_call_id="call_1", tool_kwargs='{"q": "test"}'),
    ],
)

result = to_openai_responses_message_dict(msg, model="o3-mini")
print(result)
# Actual:
#   [{"type": "function_call", "arguments": ..., "call_id": "call_1", "name": "search"}]
#
# Expected:
#   [{"role": "assistant", "content": "I'll search for that information now."},
#    {"type": "function_call", "arguments": ..., "call_id": "call_1", "name": "search"}]

if tool_calls:
    items = [*reasoning]
    if message_dict.get("content") not in (None, "", []):
        items.append(message_dict)
    items.extend(tool_calls)
    return items

# Upstream code (simplified)
for item in output:
    if isinstance(item, ResponseOutputMessage):
        for part in item.content:
            if hasattr(part, "text"):
                blocks.append(TextBlock(text=part.text))
        # item.phase is never accessed

from unittest.mock import MagicMock
from llama_index.llms.openai import OpenAIResponses

# Simulate a response with phase="commentary"
mock_msg = MagicMock()
mock_msg.type = "message"
mock_msg.role = "assistant"
mock_msg.phase = "commentary"

mock_text = MagicMock()
mock_text.text = "Let me think about this..."
mock_text.annotations = []
mock_text.refusal = None
mock_msg.content = [mock_text]

# Need to make isinstance() work — use the real type
from openai.types.responses import ResponseOutputMessage
mock_msg.__class__ = ResponseOutputMessage

result = OpenAIResponses._parse_response_output([mock_msg])
print(result.message.additional_kwargs)
# Actual:   {"built_in_tool_calls": []}
# Expected: {"built_in_tool_calls": [], "phase": "commentary"}

if isinstance(item, ResponseOutputMessage):
    item_phase = getattr(item, "phase", None)
    if item_phase in ("commentary", "final_answer"):
        phase = item_phase
    # ... existing content parsing ...

# After the loop:
if phase is not None:
    message.additional_kwargs["phase"] = phase

# Upstream code
message_dict = {
    "role": message.role.value,
    "content": ...,
}
# No phase handling for assistant messages

if message.role == MessageRole.ASSISTANT:
    phase = message.additional_kwargs.get("phase")
    if phase in ("commentary", "final_answer"):
        message_dict["phase"] = phase

# Upstream __init__
if model in O1_MODELS:         # exact match only
    temperature = 1.0

# Upstream _get_model_kwargs
if self.model in O1_MODELS and self.reasoning_options is not None:
    model_kwargs["reasoning"] = self.reasoning_options

if self.reasoning_options is not None or self.model in O1_MODELS:
    for param in params_to_exclude_for_reasoning:
        model_kwargs.pop(param, None)

from llama_index.llms.openai import OpenAIResponses

# A valid dated snapshot not in O1_MODELS
llm = OpenAIResponses(
    model="gpt-5.4-2026-03-05",
    temperature=0.3,
    reasoning_options={"effort": "low", "summary": "concise"},
    api_key="sk-test",
)

kwargs = llm._get_model_kwargs()
print("reasoning" in kwargs)  # False — reasoning options silently dropped
print("temperature" in kwargs)  # True — should have been stripped for this model

def _supports_reasoning(model: str) -> bool:
    return model.startswith(("o1-", "o3-", "o4-", "gpt-5-", "gpt-5."))

# Upstream code
if hasattr(response.usage.output_tokens_details, "reasoning_tokens"):
    for block in chat_response.message.blocks:
        if isinstance(block, ThinkingBlock):
            block.num_tokens = response.usage.output_tokens_details.reasoning_tokens
            # ^ Every block gets the TOTAL count

from llama_index.core.base.llms.types import ThinkingBlock

# Simulate: 3 reasoning blocks, 900 total reasoning tokens
blocks = [ThinkingBlock(content=f"step {i}") for i in range(3)]

# Upstream assigns 900 to each:
total = 900
for block in blocks:
    block.num_tokens = total

print([b.num_tokens for b in blocks])
# Actual:   [900, 900, 900]  (total appears to be 2700)
# Expected: [300, 300, 300]  (evenly distributed)

reasoning_blocks = [b for b in chat_response.message.blocks if isinstance(b, ThinkingBlock)]
if reasoning_blocks:
    total = response.usage.output_tokens_details.reasoning_tokens or 0
    per_block = total // len(reasoning_blocks)
    remainder = total % len(reasoning_blocks)
    for i, block in enumerate(reasoning_blocks):
        block.num_tokens = per_block + (1 if i < remainder else 0)

# Upstream code
tool_calls.extend([{
    "type": "function_call",
    "arguments": block.tool_kwargs,   # <-- may be a dict
    "call_id": block.tool_call_id,
    "name": block.tool_name,
}])

def _serialize_arguments(value):
    return value if isinstance(value, str) else json.dumps(value)