WIP build reasoning_details from ThinkingParts

Author: ajac-zero

pydantic_ai_slim/pydantic_ai/models/openrouter.py

@@ -243,7 +243,7 @@ class BaseReasoningDetail(BaseModel):
     """Common fields shared across all reasoning detail types."""
 
     id: str | None = None
-    format: Literal['unknown', 'openai-responses-v1', 'anthropic-claude-v1']
+    format: Literal['unknown', 'openai-responses-v1', 'anthropic-claude-v1', 'xai-responses-v1']
     index: int | None
 
 
@@ -320,7 +320,7 @@ def _openrouter_settings_to_openai_settings(model_settings: OpenRouterModelSetti
     Returns:
         An 'OpenAIChatModelSettings' object with equivalent settings.
     """
-    extra_body = model_settings['extra_body']
+    extra_body = model_settings.get('extra_body', {})
 
     if models := model_settings.pop('openrouter_models', None):
         extra_body['models'] = models
@@ -386,39 +386,51 @@ def _process_response(self, response: ChatCompletion | str) -> ModelResponse:
             # This is done because 'super()._process_response' reads 'reasoning' to create a ThinkingPart.
             # but this method will also create a ThinkingPart  using 'reasoning_details'; Delete 'reasoning' to avoid duplication
             if choice.message.reasoning is not None:
-                setattr(response.choices[0].message, 'reasoning', None)
+                delattr(response.choices[0].message, 'reasoning')
 
         model_response = super()._process_response(response=response)
 
-        provider_details: dict[str, Any] = {}
+        provider_details = model_response.provider_details or {}
         provider_details['downstream_provider'] = native_response.provider
         provider_details['native_finish_reason'] = choice.native_finish_reason
 
         if reasoning_details := choice.message.reasoning_details:
-            provider_details['reasoning_details'] = [detail.model_dump() for detail in reasoning_details]
-
             reasoning = reasoning_details[0]
 
-            assert isinstance(model_response.parts, list)
+            new_parts: list[ThinkingPart] = []
+
             if isinstance(reasoning, ReasoningText):
-                model_response.parts.insert(
-                    0,
+                new_parts.append(
                     ThinkingPart(
                         id=reasoning.id,
                         content=reasoning.text,
                         signature=reasoning.signature,
                         provider_name=native_response.provider,
-                    ),
+                    )
                 )
             elif isinstance(reasoning, ReasoningSummary):
-                model_response.parts.insert(
-                    0,
+                new_parts.append(
                     ThinkingPart(
                         id=reasoning.id,
                         content=reasoning.summary,
                         provider_name=native_response.provider,
                     ),
                 )
+            else:
+                new_parts.append(
+                    ThinkingPart(
+                        id=reasoning.id,
+                        content='',
+                        signature=reasoning.data,
+                        provider_name=native_response.provider,
+                    ),
+                )
+
+            # TODO: Find a better way to store these attributes
+            new_parts[0].openrouter_type = reasoning.type
+            new_parts[0].openrouter_format = reasoning.format
+
+            model_response.parts = [*new_parts, *model_response.parts]
 
         model_response.provider_details = provider_details
 
@@ -430,8 +442,24 @@ async def _map_messages(self, messages: list[ModelMessage]) -> list[ChatCompleti
 
         for message, openai_message in zip(messages, openai_messages):
             if isinstance(message, ModelResponse):
-                provider_details = cast(dict[str, Any], message.provider_details)
-                if reasoning_details := provider_details.get('reasoning_details', None):  # pragma: lax no cover
-                    openai_message['reasoning_details'] = reasoning_details  # type: ignore[reportGeneralTypeIssue]
+                for part in message.parts:
+                    if isinstance(part, ThinkingPart):
+                        reasoning_detail: dict[str, Any] = {
+                            'type': part.openrouter_type,
+                            'id': part.id,
+                            'format': part.openrouter_format,
+                            'index': 0,
+                        }
+
+                        match part.openrouter_type:
+                            case 'reasoning.summary':
+                                reasoning_detail['summary'] = part.content
+                            case 'reasoning.text':
+                                reasoning_detail['text'] = part.content
+                                reasoning_detail['signature'] = part.signature
+                            case 'reasoning.encrypted':
+                                reasoning_detail['data'] = part.signature
+
+                        openai_message['reasoning_details'] = [reasoning_detail]
 
         return openai_messages

tests/models/test_openrouter.py

@@ -92,33 +92,8 @@ async def test_openrouter_with_reasoning(allow_model_requests: None, openrouter_
 Let me structure this information in a clear, friendly manner that addresses the user's question while inviting further interaction.\
 """
     )
-    assert response.provider_details is not None
-    assert response.provider_details['reasoning_details'] == snapshot(
-        [
-            {
-                'id': None,
-                'format': 'unknown',
-                'index': 0,
-                'text': """\
-Let me process this query about who I am. First, I should consider what the user really wants to know - they're likely seeking to understand my identity and capabilities as an AI assistant.
-
-I need to be clear and accurate about my nature. I'm a GLM large language model developed by Zhipu AI, not a human. This distinction is fundamental to our interaction.
-
-Looking at my core functions, I should highlight my ability to engage in natural conversations, answer questions, and assist with various tasks. My training involves processing vast amounts of text data, which enables me to understand and generate human-like responses.
-
-It's important to mention my commitment to being helpful, harmless, and honest. These principles guide my interactions and ensure I provide appropriate assistance.
-
-I should also emphasize my continuous learning aspect. While I don't store personal data, I'm regularly updated to improve my capabilities and knowledge base.
-
-The response should be welcoming and encourage further questions about specific areas where I can help. This creates an open dialogue and shows my willingness to assist with various topics.
-
-Let me structure this information in a clear, friendly manner that addresses the user's question while inviting further interaction.\
-""",
-                'type': 'reasoning.text',
-                'signature': None,
-            }
-        ]
-    )
+    assert thinking_part.openrouter_type == snapshot('reasoning.text')
+    assert thinking_part.openrouter_format == snapshot('unknown')
 
 
 async def test_openrouter_errors_raised(allow_model_requests: None, openrouter_api_key: str) -> None: