pydantic-ai-slim 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

pydantic_ai/models/groq.py

@@ -23,6 +23,7 @@ from ..messages import (
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
     DocumentUrl,
+    FinishReason,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -100,6 +101,14 @@ but allow any name in the type hints.
 See <https://console.groq.com/docs/models> for an up to date date list of models and more details.
 """
 
+_FINISH_REASON_MAP: dict[Literal['stop', 'length', 'tool_calls', 'content_filter', 'function_call'], FinishReason] = {
+    'stop': 'stop',
+    'length': 'length',
+    'tool_calls': 'tool_call',
+    'content_filter': 'content_filter',
+    'function_call': 'tool_call',
+}
+
 
 class GroqModelSettings(ModelSettings, total=False):
     """Settings used for a Groq model request."""
@@ -186,7 +195,13 @@ class GroqModel(Model):
                         tool_name=error.error.failed_generation.name,
                         args=error.error.failed_generation.arguments,
                     )
-                    return ModelResponse(parts=[tool_call_part])
+                    return ModelResponse(
+                        parts=[tool_call_part],
+                        model_name=e.model_name,
+                        timestamp=_utils.now_utc(),
+                        provider_name=self._provider.name,
+                        finish_reason='error',
+                    )
                 except ValidationError:
                     pass
             raise
@@ -298,16 +313,16 @@ class GroqModel(Model):
                 tool_call_id = generate_tool_call_id()
                 items.append(
                     BuiltinToolCallPart(
-                        tool_name=tool.type, args=tool.arguments, provider_name='groq', tool_call_id=tool_call_id
+                        tool_name=tool.type, args=tool.arguments, provider_name=self.system, tool_call_id=tool_call_id
                     )
                 )
                 items.append(
                     BuiltinToolReturnPart(
-                        provider_name='groq', tool_name=tool.type, content=tool.output, tool_call_id=tool_call_id
+                        provider_name=self.system, tool_name=tool.type, content=tool.output, tool_call_id=tool_call_id
                     )
                 )
-        # NOTE: The `reasoning` field is only present if `groq_reasoning_format` is set to `parsed`.
         if choice.message.reasoning is not None:
+            # NOTE: The `reasoning` field is only present if `groq_reasoning_format` is set to `parsed`.
             items.append(ThinkingPart(content=choice.message.reasoning))
         if choice.message.content is not None:
             # NOTE: The `<think>` tag is only present if `groq_reasoning_format` is set to `raw`.
@@ -315,6 +330,10 @@ class GroqModel(Model):
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 items.append(ToolCallPart(tool_name=c.function.name, args=c.function.arguments, tool_call_id=c.id))
+
+        raw_finish_reason = choice.finish_reason
+        provider_details = {'finish_reason': raw_finish_reason}
+        finish_reason = _FINISH_REASON_MAP.get(raw_finish_reason)
         return ModelResponse(
             parts=items,
             usage=_map_usage(response),
@@ -322,6 +341,8 @@ class GroqModel(Model):
             timestamp=timestamp,
             provider_response_id=response.id,
             provider_name=self._provider.name,
+            finish_reason=finish_reason,
+            provider_details=provider_details,
         )
 
     async def _process_streamed_response(
@@ -338,7 +359,7 @@ class GroqModel(Model):
         return GroqStreamedResponse(
             model_request_parameters=model_request_parameters,
             _response=peekable_response,
-            _model_name=self._model_name,
+            _model_name=first_chunk.model,
             _model_profile=self.profile,
             _timestamp=number_to_datetime(first_chunk.created),
             _provider_name=self._provider.name,
@@ -376,8 +397,8 @@ class GroqModel(Model):
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
                     elif isinstance(item, ThinkingPart):
-                        # Skip thinking parts when mapping to Groq messages
-                        continue
+                        start_tag, end_tag = self.profile.thinking_tags
+                        texts.append('\n'.join([start_tag, item.content, end_tag]))
                     elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
                         # This is currently never returned from groq
                         pass
@@ -497,11 +518,18 @@ class GroqStreamedResponse(StreamedResponse):
             async for chunk in self._response:
                 self._usage += _map_usage(chunk)
 
+                if chunk.id:  # pragma: no branch
+                    self.provider_response_id = chunk.id
+
                 try:
                     choice = chunk.choices[0]
                 except IndexError:
                     continue
 
+                if raw_finish_reason := choice.finish_reason:
+                    self.provider_details = {'finish_reason': raw_finish_reason}
+                    self.finish_reason = _FINISH_REASON_MAP.get(raw_finish_reason)
+
                 # Handle the text part of the response
                 content = choice.delta.content
                 if content is not None:

pydantic_ai/models/huggingface.py

@@ -20,6 +20,7 @@ from ..messages import (
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
     DocumentUrl,
+    FinishReason,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -58,6 +59,7 @@ try:
         ChatCompletionOutput,
         ChatCompletionOutputMessage,
         ChatCompletionStreamOutput,
+        TextGenerationOutputFinishReason,
     )
     from huggingface_hub.errors import HfHubHTTPError
 
@@ -94,6 +96,12 @@ HuggingFaceModelName = str | LatestHuggingFaceModelNames
 You can browse available models [here](https://huggingface.co/models?pipeline_tag=text-generation&inference_provider=all&sort=trending).
 """
 
+_FINISH_REASON_MAP: dict[TextGenerationOutputFinishReason, FinishReason] = {
+    'length': 'length',
+    'eos_token': 'stop',
+    'stop_sequence': 'stop',
+}
+
 
 class HuggingFaceModelSettings(ModelSettings, total=False):
     """Settings used for a Hugging Face model request."""
@@ -266,6 +274,11 @@ class HuggingFaceModel(Model):
         if tool_calls is not None:
             for c in tool_calls:
                 items.append(ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id))
+
+        raw_finish_reason = choice.finish_reason
+        provider_details = {'finish_reason': raw_finish_reason}
+        finish_reason = _FINISH_REASON_MAP.get(cast(TextGenerationOutputFinishReason, raw_finish_reason), None)
+
         return ModelResponse(
             parts=items,
             usage=_map_usage(response),
@@ -273,6 +286,8 @@ class HuggingFaceModel(Model):
             timestamp=timestamp,
             provider_response_id=response.id,
             provider_name=self._provider.name,
+            finish_reason=finish_reason,
+            provider_details=provider_details,
         )
 
     async def _process_streamed_response(
@@ -288,7 +303,7 @@ class HuggingFaceModel(Model):
 
         return HuggingFaceStreamedResponse(
             model_request_parameters=model_request_parameters,
-            _model_name=self._model_name,
+            _model_name=first_chunk.model,
             _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=datetime.fromtimestamp(first_chunk.created, tz=timezone.utc),
@@ -316,10 +331,8 @@ class HuggingFaceModel(Model):
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
                     elif isinstance(item, ThinkingPart):
-                        # NOTE: We don't send ThinkingPart to the providers yet. If you are unsatisfied with this,
-                        # please open an issue. The below code is the code to send thinking to the provider.
-                        # texts.append(f'<think>\n{item.content}\n</think>')
-                        pass
+                        start_tag, end_tag = self.profile.thinking_tags
+                        texts.append('\n'.join([start_tag, item.content, end_tag]))
                     elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
                         # This is currently never returned from huggingface
                         pass
@@ -445,11 +458,20 @@ class HuggingFaceStreamedResponse(StreamedResponse):
         async for chunk in self._response:
             self._usage += _map_usage(chunk)
 
+            if chunk.id:  # pragma: no branch
+                self.provider_response_id = chunk.id
+
             try:
                 choice = chunk.choices[0]
             except IndexError:
                 continue
 
+            if raw_finish_reason := choice.finish_reason:
+                self.provider_details = {'finish_reason': raw_finish_reason}
+                self.finish_reason = _FINISH_REASON_MAP.get(
+                    cast(TextGenerationOutputFinishReason, raw_finish_reason), None
+                )
+
             # Handle the text part of the response
             content = choice.delta.content
             if content is not None:

pydantic_ai/models/mistral.py

@@ -13,7 +13,6 @@ from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
 from .._run_context import RunContext
-from .._thinking_part import split_content_into_text_and_thinking
 from .._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc, number_to_datetime
 from ..exceptions import UserError
 from ..messages import (
@@ -21,6 +20,7 @@ from ..messages import (
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
     DocumentUrl,
+    FinishReason,
     ImageUrl,
     ModelMessage,
     ModelRequest,
@@ -61,12 +61,15 @@ try:
         ImageURLChunk as MistralImageURLChunk,
         Mistral,
         OptionalNullable as MistralOptionalNullable,
+        ReferenceChunk as MistralReferenceChunk,
         TextChunk as MistralTextChunk,
+        ThinkChunk as MistralThinkChunk,
         ToolChoiceEnum as MistralToolChoiceEnum,
     )
     from mistralai.models import (
         ChatCompletionResponse as MistralChatCompletionResponse,
         CompletionEvent as MistralCompletionEvent,
+        FinishReason as MistralFinishReason,
         Messages as MistralMessages,
         SDKError,
         Tool as MistralTool,
@@ -98,6 +101,14 @@ allow any name in the type hints.
 Since [the Mistral docs](https://docs.mistral.ai/getting-started/models/models_overview/) for a full list.
 """
 
+_FINISH_REASON_MAP: dict[MistralFinishReason, FinishReason] = {
+    'stop': 'stop',
+    'length': 'length',
+    'model_length': 'length',
+    'error': 'error',
+    'tool_calls': 'tool_call',
+}
+
 
 class MistralModelSettings(ModelSettings, total=False):
     """Settings used for a Mistral model request."""
@@ -339,14 +350,21 @@ class MistralModel(Model):
         tool_calls = choice.message.tool_calls
 
         parts: list[ModelResponsePart] = []
-        if text := _map_content(content):
-            parts.extend(split_content_into_text_and_thinking(text, self.profile.thinking_tags))
+        text, thinking = _map_content(content)
+        for thought in thinking:
+            parts.append(ThinkingPart(content=thought))
+        if text:
+            parts.append(TextPart(content=text))
 
         if isinstance(tool_calls, list):
             for tool_call in tool_calls:
                 tool = self._map_mistral_to_pydantic_tool_call(tool_call=tool_call)
                 parts.append(tool)
 
+        raw_finish_reason = choice.finish_reason
+        provider_details = {'finish_reason': raw_finish_reason}
+        finish_reason = _FINISH_REASON_MAP.get(raw_finish_reason)
+
         return ModelResponse(
             parts=parts,
             usage=_map_usage(response),
@@ -354,6 +372,8 @@ class MistralModel(Model):
             timestamp=timestamp,
             provider_response_id=response.id,
             provider_name=self._provider.name,
+            finish_reason=finish_reason,
+            provider_details=provider_details,
         )
 
     async def _process_streamed_response(
@@ -377,7 +397,7 @@ class MistralModel(Model):
         return MistralStreamedResponse(
             model_request_parameters=model_request_parameters,
             _response=peekable_response,
-            _model_name=self._model_name,
+            _model_name=first_chunk.data.model,
             _timestamp=timestamp,
             _provider_name=self._provider.name,
         )
@@ -503,16 +523,14 @@ class MistralModel(Model):
                 mistral_messages.extend(self._map_user_message(message))
             elif isinstance(message, ModelResponse):
                 content_chunks: list[MistralContentChunk] = []
+                thinking_chunks: list[MistralTextChunk | MistralReferenceChunk] = []
                 tool_calls: list[MistralToolCall] = []
 
                 for part in message.parts:
                     if isinstance(part, TextPart):
                         content_chunks.append(MistralTextChunk(text=part.content))
                     elif isinstance(part, ThinkingPart):
-                        # NOTE: We don't send ThinkingPart to the providers yet. If you are unsatisfied with this,
-                        # please open an issue. The below code is the code to send thinking to the provider.
-                        # content_chunks.append(MistralTextChunk(text=f'<think>{part.content}</think>'))
-                        pass
+                        thinking_chunks.append(MistralTextChunk(text=part.content))
                     elif isinstance(part, ToolCallPart):
                         tool_calls.append(self._map_tool_call(part))
                     elif isinstance(part, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
@@ -520,6 +538,8 @@ class MistralModel(Model):
                         pass
                     else:
                         assert_never(part)
+                if thinking_chunks:
+                    content_chunks.insert(0, MistralThinkChunk(thinking=thinking_chunks))
                 mistral_messages.append(MistralAssistantMessage(content=content_chunks, tool_calls=tool_calls))
             else:
                 assert_never(message)
@@ -595,14 +615,23 @@ class MistralStreamedResponse(StreamedResponse):
         async for chunk in self._response:
             self._usage += _map_usage(chunk.data)
 
+            if chunk.data.id:  # pragma: no branch
+                self.provider_response_id = chunk.data.id
+
             try:
                 choice = chunk.data.choices[0]
             except IndexError:
                 continue
 
+            if raw_finish_reason := choice.finish_reason:
+                self.provider_details = {'finish_reason': raw_finish_reason}
+                self.finish_reason = _FINISH_REASON_MAP.get(raw_finish_reason)
+
             # Handle the text part of the response
             content = choice.delta.content
-            text = _map_content(content)
+            text, thinking = _map_content(content)
+            for thought in thinking:
+                self._parts_manager.handle_thinking_delta(vendor_part_id='thinking', content=thought)
             if text:
                 # Attempt to produce an output tool call from the received text
                 output_tools = {c.name: c for c in self.model_request_parameters.output_tools}
@@ -715,32 +744,37 @@ def _map_usage(response: MistralChatCompletionResponse | MistralCompletionChunk)
     """Maps a Mistral Completion Chunk or Chat Completion Response to a Usage."""
     if response.usage:
         return RequestUsage(
-            input_tokens=response.usage.prompt_tokens,
-            output_tokens=response.usage.completion_tokens,
+            input_tokens=response.usage.prompt_tokens or 0,
+            output_tokens=response.usage.completion_tokens or 0,
         )
     else:
-        return RequestUsage()  # pragma: no cover
+        return RequestUsage()
 
 
-def _map_content(content: MistralOptionalNullable[MistralContent]) -> str | None:
+def _map_content(content: MistralOptionalNullable[MistralContent]) -> tuple[str | None, list[str]]:
     """Maps the delta content from a Mistral Completion Chunk to a string or None."""
-    output: str | None = None
+    text: str | None = None
+    thinking: list[str] = []
 
     if isinstance(content, MistralUnset) or not content:
-        output = None
+        return None, []
     elif isinstance(content, list):
         for chunk in content:
             if isinstance(chunk, MistralTextChunk):
-                output = output or '' + chunk.text
+                text = text or '' + chunk.text
+            elif isinstance(chunk, MistralThinkChunk):
+                for thought in chunk.thinking:
+                    if thought.type == 'text':  # pragma: no branch
+                        thinking.append(thought.text)
             else:
                 assert False, (  # pragma: no cover
                     f'Other data types like (Image, Reference) are not yet supported,  got {type(chunk)}'
                 )
     elif isinstance(content, str):
-        output = content
+        text = content
 
     # Note: Check len to handle potential mismatch between function calls and responses from the API. (`msg: not the same number of function class and responses`)
-    if output and len(output) == 0:  # pragma: no cover
-        output = None
+    if text and len(text) == 0:  # pragma: no cover
+        text = None
 
-    return output
+    return text, thinking

pydantic_ai/models/openai.py

@@ -4,7 +4,7 @@ import base64
 import warnings
 from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from datetime import datetime
 from typing import Any, Literal, cast, overload
 
@@ -31,6 +31,7 @@ from ..messages import (
     ModelResponse,
     ModelResponsePart,
     ModelResponseStreamEvent,
+    PartStartEvent,
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
@@ -73,6 +74,7 @@ try:
     )
     from openai.types.responses import ComputerToolParam, FileSearchToolParam, WebSearchToolParam
     from openai.types.responses.response_input_param import FunctionCallOutput, Message
+    from openai.types.responses.response_reasoning_item_param import Summary
     from openai.types.responses.response_status import ResponseStatus
     from openai.types.shared import ReasoningEffort
     from openai.types.shared_params import Reasoning
@@ -491,9 +493,17 @@ class OpenAIChatModel(Model):
 
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
-        # The `reasoning_content` is only present in DeepSeek models.
+        # The `reasoning_content` field is only present in DeepSeek models.
+        # https://api-docs.deepseek.com/guides/reasoning_model
         if reasoning_content := getattr(choice.message, 'reasoning_content', None):
-            items.append(ThinkingPart(content=reasoning_content))
+            items.append(ThinkingPart(id='reasoning_content', content=reasoning_content, provider_name=self.system))
+
+        # NOTE: We don't currently handle OpenRouter `reasoning_details`:
+        # - https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks
+        # NOTE: We don't currently handle OpenRouter/gpt-oss `reasoning`:
+        # - https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot#chat-completions-api
+        # - https://openrouter.ai/docs/use-cases/reasoning-tokens#basic-usage-with-reasoning-tokens
+        # If you need this, please file an issue.
 
         vendor_details: dict[str, Any] = {}
 
@@ -513,7 +523,10 @@ class OpenAIChatModel(Model):
             ]
 
         if choice.message.content is not None:
-            items.extend(split_content_into_text_and_thinking(choice.message.content, self.profile.thinking_tags))
+            items.extend(
+                (replace(part, id='content', provider_name=self.system) if isinstance(part, ThinkingPart) else part)
+                for part in split_content_into_text_and_thinking(choice.message.content, self.profile.thinking_tags)
+            )
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 if isinstance(c, ChatCompletionMessageFunctionToolCall):
@@ -527,10 +540,9 @@ class OpenAIChatModel(Model):
                 part.tool_call_id = _guard_tool_call_id(part)
                 items.append(part)
 
-        finish_reason: FinishReason | None = None
-        if raw_finish_reason := choice.finish_reason:  # pragma: no branch
-            vendor_details['finish_reason'] = raw_finish_reason
-            finish_reason = _CHAT_FINISH_REASON_MAP.get(raw_finish_reason)
+        raw_finish_reason = choice.finish_reason
+        vendor_details['finish_reason'] = raw_finish_reason
+        finish_reason = _CHAT_FINISH_REASON_MAP.get(raw_finish_reason)
 
         return ModelResponse(
             parts=items,
@@ -556,7 +568,7 @@ class OpenAIChatModel(Model):
 
         return OpenAIStreamedResponse(
             model_request_parameters=model_request_parameters,
-            _model_name=self._model_name,
+            _model_name=first_chunk.model,
             _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.created),
@@ -569,6 +581,12 @@ class OpenAIChatModel(Model):
     def _get_web_search_options(self, model_request_parameters: ModelRequestParameters) -> WebSearchOptions | None:
         for tool in model_request_parameters.builtin_tools:
             if isinstance(tool, WebSearchTool):  # pragma: no branch
+                if not OpenAIModelProfile.from_profile(self.profile).openai_chat_supports_web_search:
+                    raise UserError(
+                        f'WebSearchTool is not supported with `OpenAIChatModel` and model {self.model_name!r}. '
+                        f'Please use `OpenAIResponsesModel` instead.'
+                    )
+
                 if tool.user_location:
                     return WebSearchOptions(
                         search_context_size=tool.search_context_size,
@@ -580,7 +598,7 @@ class OpenAIChatModel(Model):
                 return WebSearchOptions(search_context_size=tool.search_context_size)
             else:
                 raise UserError(
-                    f'`{tool.__class__.__name__}` is not supported by `OpenAIModel`. If it should be, please file an issue.'
+                    f'`{tool.__class__.__name__}` is not supported by `OpenAIChatModel`. If it should be, please file an issue.'
                 )
 
     async def _map_messages(self, messages: list[ModelMessage]) -> list[chat.ChatCompletionMessageParam]:
@@ -597,10 +615,11 @@ class OpenAIChatModel(Model):
                     if isinstance(item, TextPart):
                         texts.append(item.content)
                     elif isinstance(item, ThinkingPart):
-                        # NOTE: We don't send ThinkingPart to the providers yet. If you are unsatisfied with this,
-                        # please open an issue. The below code is the code to send thinking to the provider.
-                        # texts.append(f'<think>\n{item.content}\n</think>')
-                        pass
+                        # NOTE: DeepSeek `reasoning_content` field should NOT be sent back per https://api-docs.deepseek.com/guides/reasoning_model,
+                        # but we currently just send it in `<think>` tags anyway as we don't want DeepSeek-specific checks here.
+                        # If you need this changed, please file an issue.
+                        start_tag, end_tag = self.profile.thinking_tags
+                        texts.append('\n'.join([start_tag, item.content, end_tag]))
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
                     # OpenAI doesn't return built-in tool calls
@@ -838,16 +857,27 @@ class OpenAIResponsesModel(Model):
         timestamp = number_to_datetime(response.created_at)
         items: list[ModelResponsePart] = []
         for item in response.output:
-            if item.type == 'reasoning':
+            if isinstance(item, responses.ResponseReasoningItem):
+                signature = item.encrypted_content
                 for summary in item.summary:
-                    # NOTE: We use the same id for all summaries because we can merge them on the round trip.
-                    # The providers don't force the signature to be unique.
-                    items.append(ThinkingPart(content=summary.text, id=item.id))
-            elif item.type == 'message':
+                    # We use the same id for all summaries so that we can merge them on the round trip.
+                    # We only need to store the signature once.
+                    items.append(
+                        ThinkingPart(
+                            content=summary.text,
+                            id=item.id,
+                            signature=signature,
+                            provider_name=self.system if signature else None,
+                        )
+                    )
+                    signature = None
+                # NOTE: We don't currently handle the raw CoT from gpt-oss `reasoning_text`: https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot
+                # If you need this, please file an issue.
+            elif isinstance(item, responses.ResponseOutputMessage):
                 for content in item.content:
-                    if content.type == 'output_text':  # pragma: no branch
+                    if isinstance(content, responses.ResponseOutputText):  # pragma: no branch
                         items.append(TextPart(content.text))
-            elif item.type == 'function_call':
+            elif isinstance(item, responses.ResponseFunctionToolCall):
                 items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
 
         finish_reason: FinishReason | None = None
@@ -882,7 +912,7 @@ class OpenAIResponsesModel(Model):
         assert isinstance(first_chunk, responses.ResponseCreatedEvent)
         return OpenAIResponsesStreamedResponse(
             model_request_parameters=model_request_parameters,
-            _model_name=self._model_name,
+            _model_name=first_chunk.response.model,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.response.created_at),
             _provider_name=self._provider.name,
@@ -974,6 +1004,7 @@ class OpenAIResponsesModel(Model):
                 reasoning=reasoning,
                 user=model_settings.get('openai_user', NOT_GIVEN),
                 text=text or NOT_GIVEN,
+                include=['reasoning.encrypted_content'],
                 extra_headers=extra_headers,
                 extra_body=model_settings.get('extra_body'),
             )
@@ -1035,7 +1066,7 @@ class OpenAIResponsesModel(Model):
             ),
         }
 
-    async def _map_messages(
+    async def _map_messages(  # noqa: C901
         self, messages: list[ModelMessage]
     ) -> tuple[str | NotGiven, list[responses.ResponseInputItemParam]]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.responses.ResponseInputParam`."""
@@ -1072,33 +1103,30 @@ class OpenAIResponsesModel(Model):
                     else:
                         assert_never(part)
             elif isinstance(message, ModelResponse):
-                # last_thinking_part_idx: int | None = None
+                reasoning_item: responses.ResponseReasoningItemParam | None = None
                 for item in message.parts:
                     if isinstance(item, TextPart):
                         openai_messages.append(responses.EasyInputMessageParam(role='assistant', content=item.content))
                     elif isinstance(item, ToolCallPart):
                         openai_messages.append(self._map_tool_call(item))
-                    # OpenAI doesn't return built-in tool calls
                     elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):
+                        # We don't currently track built-in tool calls from OpenAI
                         pass
                     elif isinstance(item, ThinkingPart):
-                        # NOTE: We don't send ThinkingPart to the providers yet. If you are unsatisfied with this,
-                        # please open an issue. The below code is the code to send thinking to the provider.
-                        # if last_thinking_part_idx is not None:
-                        #     reasoning_item = cast(responses.ResponseReasoningItemParam, openai_messages[last_thinking_part_idx])  # fmt: skip
-                        #     if item.id == reasoning_item['id']:
-                        #         assert isinstance(reasoning_item['summary'], list)
-                        #         reasoning_item['summary'].append(Summary(text=item.content, type='summary_text'))
-                        #         continue
-                        # last_thinking_part_idx = len(openai_messages)
-                        # openai_messages.append(
-                        #     responses.ResponseReasoningItemParam(
-                        #         id=item.id or generate_tool_call_id(),
-                        #         summary=[Summary(text=item.content, type='summary_text')],
-                        #         type='reasoning',
-                        #     )
-                        # )
-                        pass
+                        if reasoning_item is not None and item.id == reasoning_item['id']:
+                            reasoning_item['summary'] = [
+                                *reasoning_item['summary'],
+                                Summary(text=item.content, type='summary_text'),
+                            ]
+                            continue
+
+                        reasoning_item = responses.ResponseReasoningItemParam(
+                            id=item.id or _utils.generate_tool_call_id(),
+                            summary=[Summary(text=item.content, type='summary_text')],
+                            encrypted_content=item.signature if item.provider_name == self.system else None,
+                            type='reasoning',
+                        )
+                        openai_messages.append(reasoning_item)
                     else:
                         assert_never(item)
             else:
@@ -1231,12 +1259,19 @@ class OpenAIStreamedResponse(StreamedResponse):
                     ignore_leading_whitespace=self._model_profile.ignore_streamed_leading_whitespace,
                 )
                 if maybe_event is not None:  # pragma: no branch
+                    if isinstance(maybe_event, PartStartEvent) and isinstance(maybe_event.part, ThinkingPart):
+                        maybe_event.part.id = 'content'
+                        maybe_event.part.provider_name = self.provider_name
                     yield maybe_event
 
-            # Handle reasoning part of the response, present in DeepSeek models
+            # The `reasoning_content` field is only present in DeepSeek models.
+            # https://api-docs.deepseek.com/guides/reasoning_model
             if reasoning_content := getattr(choice.delta, 'reasoning_content', None):
                 yield self._parts_manager.handle_thinking_delta(
-                    vendor_part_id='reasoning_content', content=reasoning_content
+                    vendor_part_id='reasoning_content',
+                    id='reasoning_content',
+                    content=reasoning_content,
+                    provider_name=self.provider_name,
                 )
 
             for dtc in choice.delta.tool_calls or []:
@@ -1340,7 +1375,15 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                     )
 
             elif isinstance(chunk, responses.ResponseOutputItemDoneEvent):
-                # NOTE: We only need this if the tool call deltas don't include the final info.
+                if isinstance(chunk.item, responses.ResponseReasoningItem):
+                    # Add the signature to the part corresponding to the first summary item
+                    signature = chunk.item.encrypted_content
+                    yield self._parts_manager.handle_thinking_delta(
+                        vendor_part_id=f'{chunk.item.id}-0',
+                        id=chunk.item.id,
+                        signature=signature,
+                        provider_name=self.provider_name if signature else None,
+                    )
                 pass
 
             elif isinstance(chunk, responses.ResponseReasoningSummaryPartAddedEvent):