pydantic-ai-slim 0.2.20__py3-none-any.whl → 0.3.0__py3-none-any.whl

pydantic_ai/_agent_graph.py

@@ -442,7 +442,7 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         async for _event in stream:
             pass
 
-    async def _run_stream(
+    async def _run_stream(  # noqa: C901
         self, ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]
     ) -> AsyncIterator[_messages.HandleResponseEvent]:
         if self._events_iterator is None:
@@ -458,6 +458,12 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                             texts.append(part.content)
                     elif isinstance(part, _messages.ToolCallPart):
                         tool_calls.append(part)
+                    elif isinstance(part, _messages.ThinkingPart):
+                        # We don't need to do anything with thinking parts in this tool-calling node.
+                        # We need to handle text parts in case there are no tool calls and/or the desired output comes
+                        # from the text, but thinking parts should not directly influence the execution of tools or
+                        # determination of the next node of graph execution here.
+                        pass
                     else:
                         assert_never(part)
 

pydantic_ai/_parts_manager.py

@@ -25,6 +25,8 @@ from pydantic_ai.messages import (
     PartStartEvent,
     TextPart,
     TextPartDelta,
+    ThinkingPart,
+    ThinkingPartDelta,
     ToolCallPart,
     ToolCallPartDelta,
 )
@@ -86,8 +88,7 @@ class ModelResponsePartsManager:
             A `PartStartEvent` if a new part was created, or a `PartDeltaEvent` if an existing part was updated.
 
         Raises:
-            UnexpectedModelBehavior: If attempting to apply text content to a part that is
-                not a TextPart.
+            UnexpectedModelBehavior: If attempting to apply text content to a part that is not a TextPart.
         """
         existing_text_part_and_index: tuple[TextPart, int] | None = None
 
@@ -122,6 +123,77 @@ class ModelResponsePartsManager:
             self._parts[part_index] = part_delta.apply(existing_text_part)
             return PartDeltaEvent(index=part_index, delta=part_delta)
 
+    def handle_thinking_delta(
+        self,
+        *,
+        vendor_part_id: Hashable | None,
+        content: str | None = None,
+        signature: str | None = None,
+    ) -> ModelResponseStreamEvent:
+        """Handle incoming thinking content, creating or updating a ThinkingPart in the manager as appropriate.
+
+        When `vendor_part_id` is None, the latest part is updated if it exists and is a ThinkingPart;
+        otherwise, a new ThinkingPart is created. When a non-None ID is specified, the ThinkingPart corresponding
+        to that vendor ID is either created or updated.
+
+        Args:
+            vendor_part_id: The ID the vendor uses to identify this piece
+                of thinking. If None, a new part will be created unless the latest part is already
+                a ThinkingPart.
+            content: The thinking content to append to the appropriate ThinkingPart.
+            signature: An optional signature for the thinking content.
+
+        Returns:
+            A `PartStartEvent` if a new part was created, or a `PartDeltaEvent` if an existing part was updated.
+
+        Raises:
+            UnexpectedModelBehavior: If attempting to apply a thinking delta to a part that is not a ThinkingPart.
+        """
+        existing_thinking_part_and_index: tuple[ThinkingPart, int] | None = None
+
+        if vendor_part_id is None:
+            # If the vendor_part_id is None, check if the latest part is a ThinkingPart to update
+            if self._parts:
+                part_index = len(self._parts) - 1
+                latest_part = self._parts[part_index]
+                if isinstance(latest_part, ThinkingPart):  # pragma: no branch
+                    existing_thinking_part_and_index = latest_part, part_index
+        else:
+            # Otherwise, attempt to look up an existing ThinkingPart by vendor_part_id
+            part_index = self._vendor_id_to_part_index.get(vendor_part_id)
+            if part_index is not None:
+                existing_part = self._parts[part_index]
+                if not isinstance(existing_part, ThinkingPart):
+                    raise UnexpectedModelBehavior(f'Cannot apply a thinking delta to {existing_part=}')
+                existing_thinking_part_and_index = existing_part, part_index
+
+        if existing_thinking_part_and_index is None:
+            if content is not None:
+                # There is no existing thinking part that should be updated, so create a new one
+                new_part_index = len(self._parts)
+                part = ThinkingPart(content=content, signature=signature)
+                if vendor_part_id is not None:  # pragma: no branch
+                    self._vendor_id_to_part_index[vendor_part_id] = new_part_index
+                self._parts.append(part)
+                return PartStartEvent(index=new_part_index, part=part)
+            else:
+                raise UnexpectedModelBehavior('Cannot create a ThinkingPart with no content')
+        else:
+            if content is not None:
+                # Update the existing ThinkingPart with the new content delta
+                existing_thinking_part, part_index = existing_thinking_part_and_index
+                part_delta = ThinkingPartDelta(content_delta=content)
+                self._parts[part_index] = part_delta.apply(existing_thinking_part)
+                return PartDeltaEvent(index=part_index, delta=part_delta)
+            elif signature is not None:
+                # Update the existing ThinkingPart with the new signature delta
+                existing_thinking_part, part_index = existing_thinking_part_and_index
+                part_delta = ThinkingPartDelta(signature_delta=signature)
+                self._parts[part_index] = part_delta.apply(existing_thinking_part)
+                return PartDeltaEvent(index=part_index, delta=part_delta)
+            else:
+                raise UnexpectedModelBehavior('Cannot update a ThinkingPart with no content or signature')
+
     def handle_tool_call_delta(
         self,
         *,

pydantic_ai/_thinking_part.py

@@ -0,0 +1,36 @@
+from __future__ import annotations as _annotations
+
+from pydantic_ai.messages import TextPart, ThinkingPart
+
+START_THINK_TAG = '<think>'
+END_THINK_TAG = '</think>'
+
+
+def split_content_into_text_and_thinking(content: str) -> list[ThinkingPart | TextPart]:
+    """Split a string into text and thinking parts.
+
+    Some models don't return the thinking part as a separate part, but rather as a tag in the content.
+    This function splits the content into text and thinking parts.
+
+    We use the `<think>` tag because that's how Groq uses it in the `raw` format, so instead of using `<Thinking>` or
+    something else, we just match the tag to make it easier for other models that don't support the `ThinkingPart`.
+    """
+    parts: list[ThinkingPart | TextPart] = []
+
+    start_index = content.find(START_THINK_TAG)
+    while start_index >= 0:
+        before_think, content = content[:start_index], content[start_index + len(START_THINK_TAG) :]
+        if before_think:
+            parts.append(TextPart(content=before_think))
+        end_index = content.find(END_THINK_TAG)
+        if end_index >= 0:
+            think_content, content = content[:end_index], content[end_index + len(END_THINK_TAG) :]
+            parts.append(ThinkingPart(content=think_content))
+        else:
+            # We lose the `<think>` tag, but it shouldn't matter.
+            parts.append(TextPart(content=content))
+            content = ''
+        start_index = content.find(START_THINK_TAG)
+    if content:
+        parts.append(TextPart(content=content))
+    return parts

pydantic_ai/messages.py

@@ -14,7 +14,10 @@ from opentelemetry._events import Event  # pyright: ignore[reportPrivateImportUs
 from typing_extensions import TypeAlias
 
 from . import _utils
-from ._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc
+from ._utils import (
+    generate_tool_call_id as _generate_tool_call_id,
+    now_utc as _now_utc,
+)
 from .exceptions import UnexpectedModelBehavior
 from .usage import Usage
 
@@ -531,6 +534,32 @@ class TextPart:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
+@dataclass(repr=False)
+class ThinkingPart:
+    """A thinking response from a model."""
+
+    content: str
+    """The thinking content of the response."""
+
+    id: str | None = None
+    """The identifier of the thinking part."""
+
+    signature: str | None = None
+    """The signature of the thinking.
+
+    The signature is only available on the Anthropic models.
+    """
+
+    part_kind: Literal['thinking'] = 'thinking'
+    """Part type identifier, this is available on all parts as a discriminator."""
+
+    def has_content(self) -> bool:
+        """Return `True` if the thinking content is non-empty."""
+        return bool(self.content)  # pragma: no cover
+
+    __repr__ = _utils.dataclasses_no_defaults_repr
+
+
 @dataclass(repr=False)
 class ToolCallPart:
     """A tool call from a model."""
@@ -589,7 +618,7 @@ class ToolCallPart:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-ModelResponsePart = Annotated[Union[TextPart, ToolCallPart], pydantic.Discriminator('part_kind')]
+ModelResponsePart = Annotated[Union[TextPart, ToolCallPart, ThinkingPart], pydantic.Discriminator('part_kind')]
 """A message part returned by a model."""
 
 
@@ -699,6 +728,56 @@ class TextPartDelta:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
+@dataclass(repr=False)
+class ThinkingPartDelta:
+    """A partial update (delta) for a `ThinkingPart` to append new thinking content."""
+
+    content_delta: str | None = None
+    """The incremental thinking content to add to the existing `ThinkingPart` content."""
+
+    signature_delta: str | None = None
+    """Optional signature delta.
+
+    Note this is never treated as a delta — it can replace None.
+    """
+
+    part_delta_kind: Literal['thinking'] = 'thinking'
+    """Part delta type identifier, used as a discriminator."""
+
+    @overload
+    def apply(self, part: ModelResponsePart) -> ThinkingPart: ...
+
+    @overload
+    def apply(self, part: ModelResponsePart | ThinkingPartDelta) -> ThinkingPart | ThinkingPartDelta: ...
+
+    def apply(self, part: ModelResponsePart | ThinkingPartDelta) -> ThinkingPart | ThinkingPartDelta:
+        """Apply this thinking delta to an existing `ThinkingPart`.
+
+        Args:
+            part: The existing model response part, which must be a `ThinkingPart`.
+
+        Returns:
+            A new `ThinkingPart` with updated thinking content.
+
+        Raises:
+            ValueError: If `part` is not a `ThinkingPart`.
+        """
+        if isinstance(part, ThinkingPart):
+            return replace(part, content=part.content + self.content_delta if self.content_delta else None)
+        elif isinstance(part, ThinkingPartDelta):
+            if self.content_delta is None and self.signature_delta is None:
+                raise ValueError('Cannot apply ThinkingPartDelta with no content or signature')
+            if self.signature_delta is not None:
+                return replace(part, signature_delta=self.signature_delta)
+            if self.content_delta is not None:
+                return replace(part, content_delta=self.content_delta)
+        raise ValueError(  # pragma: no cover
+            f'Cannot apply ThinkingPartDeltas to non-ThinkingParts or non-ThinkingPartDeltas ({part=}, {self=})'
+        )
+
+    __repr__ = _utils.dataclasses_no_defaults_repr
+
+
 @dataclass(repr=False)
 class ToolCallPartDelta:
     """A partial update (delta) for a `ToolCallPart` to modify tool name, arguments, or tool call ID."""
@@ -818,7 +897,9 @@ class ToolCallPartDelta:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
-ModelResponsePartDelta = Annotated[Union[TextPartDelta, ToolCallPartDelta], pydantic.Discriminator('part_delta_kind')]
+ModelResponsePartDelta = Annotated[
+    Union[TextPartDelta, ThinkingPartDelta, ToolCallPartDelta], pydantic.Discriminator('part_delta_kind')
+]
 """A partial update (delta) for any model response part."""
 
 

pydantic_ai/models/anthropic.py

@@ -1,6 +1,7 @@
 from __future__ import annotations as _annotations
 
 import io
+import warnings
 from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
@@ -23,6 +24,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -52,9 +54,15 @@ try:
         BetaRawMessageStartEvent,
         BetaRawMessageStopEvent,
         BetaRawMessageStreamEvent,
+        BetaRedactedThinkingBlock,
+        BetaSignatureDelta,
         BetaTextBlock,
         BetaTextBlockParam,
         BetaTextDelta,
+        BetaThinkingBlock,
+        BetaThinkingBlockParam,
+        BetaThinkingConfigParam,
+        BetaThinkingDelta,
         BetaToolChoiceParam,
         BetaToolParam,
         BetaToolResultBlockParam,
@@ -90,7 +98,14 @@ class AnthropicModelSettings(ModelSettings, total=False):
     anthropic_metadata: BetaMetadataParam
     """An object describing metadata about the request.
 
-    Contains `user_id`, an external identifier for the user who is associated with the request."""
+    Contains `user_id`, an external identifier for the user who is associated with the request.
+    """
+
+    anthropic_thinking: BetaThinkingConfigParam
+    """Determine whether the model should generate a thinking block.
+
+    See [the Anthropic docs](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) for more information.
+    """
 
 
 @dataclass(init=False)
@@ -227,6 +242,7 @@ class AnthropicModel(Model):
                 tools=tools or NOT_GIVEN,
                 tool_choice=tool_choice or NOT_GIVEN,
                 stream=stream,
+                thinking=model_settings.get('anthropic_thinking', NOT_GIVEN),
                 stop_sequences=model_settings.get('stop_sequences', NOT_GIVEN),
                 temperature=model_settings.get('temperature', NOT_GIVEN),
                 top_p=model_settings.get('top_p', NOT_GIVEN),
@@ -246,6 +262,14 @@ class AnthropicModel(Model):
         for item in response.content:
             if isinstance(item, BetaTextBlock):
                 items.append(TextPart(content=item.text))
+            elif isinstance(item, BetaRedactedThinkingBlock):  # pragma: no cover
+                warnings.warn(
+                    'PydanticAI currently does not handle redacted thinking blocks. '
+                    'If you have a suggestion on how we should handle them, please open an issue.',
+                    UserWarning,
+                )
+            elif isinstance(item, BetaThinkingBlock):
+                items.append(ThinkingPart(content=item.thinking, signature=item.signature))
             else:
                 assert isinstance(item, BetaToolUseBlock), f'unexpected item type {type(item)}'
                 items.append(
@@ -312,11 +336,21 @@ class AnthropicModel(Model):
                 if len(user_content_params) > 0:
                     anthropic_messages.append(BetaMessageParam(role='user', content=user_content_params))
             elif isinstance(m, ModelResponse):
-                assistant_content_params: list[BetaTextBlockParam | BetaToolUseBlockParam] = []
+                assistant_content_params: list[BetaTextBlockParam | BetaToolUseBlockParam | BetaThinkingBlockParam] = []
                 for response_part in m.parts:
                     if isinstance(response_part, TextPart):
                         if response_part.content:  # Only add non-empty text
                             assistant_content_params.append(BetaTextBlockParam(text=response_part.content, type='text'))
+                    elif isinstance(response_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.
+                        # assert response_part.signature is not None, 'Thinking part must have a signature'
+                        # assistant_content_params.append(
+                        #     BetaThinkingBlockParam(
+                        #         thinking=response_part.content, signature=response_part.signature, type='thinking'
+                        #     )
+                        # )
+                        pass
                     else:
                         tool_use_block_param = BetaToolUseBlockParam(
                             id=_guard_tool_call_id(t=response_part),
@@ -445,10 +479,14 @@ class AnthropicStreamedResponse(StreamedResponse):
             if isinstance(event, BetaRawContentBlockStartEvent):
                 current_block = event.content_block
                 if isinstance(current_block, BetaTextBlock) and current_block.text:
-                    yield self._parts_manager.handle_text_delta(  # pragma: lax no cover
-                        vendor_part_id='content', content=current_block.text
+                    yield self._parts_manager.handle_text_delta(vendor_part_id='content', content=current_block.text)
+                elif isinstance(current_block, BetaThinkingBlock):
+                    yield self._parts_manager.handle_thinking_delta(
+                        vendor_part_id='thinking',
+                        content=current_block.thinking,
+                        signature=current_block.signature,
                     )
-                elif isinstance(current_block, BetaToolUseBlock):  # pragma: no branch
+                elif isinstance(current_block, BetaToolUseBlock):
                     maybe_event = self._parts_manager.handle_tool_call_delta(
                         vendor_part_id=current_block.id,
                         tool_name=current_block.name,
@@ -460,14 +498,20 @@ class AnthropicStreamedResponse(StreamedResponse):
 
             elif isinstance(event, BetaRawContentBlockDeltaEvent):
                 if isinstance(event.delta, BetaTextDelta):
-                    yield self._parts_manager.handle_text_delta(  # pragma: no cover
-                        vendor_part_id='content', content=event.delta.text
+                    yield self._parts_manager.handle_text_delta(vendor_part_id='content', content=event.delta.text)
+                elif isinstance(event.delta, BetaThinkingDelta):
+                    yield self._parts_manager.handle_thinking_delta(
+                        vendor_part_id='thinking', content=event.delta.thinking
+                    )
+                elif isinstance(event.delta, BetaSignatureDelta):
+                    yield self._parts_manager.handle_thinking_delta(
+                        vendor_part_id='thinking', signature=event.delta.signature
                     )
-                elif (  # pragma: no branch
+                elif (
                     current_block
                     and event.delta.type == 'input_json_delta'
                     and isinstance(current_block, BetaToolUseBlock)
-                ):
+                ):  # pragma: no branch
                     maybe_event = self._parts_manager.handle_tool_call_delta(
                         vendor_part_id=current_block.id,
                         tool_name='',

pydantic_ai/models/bedrock.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import functools
 import typing
+import warnings
 from collections.abc import AsyncIterator, Iterable, Iterator, Mapping
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
@@ -27,6 +28,7 @@ from pydantic_ai.messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -265,11 +267,16 @@ class BedrockConverseModel(Model):
         items: list[ModelResponsePart] = []
         if message := response['output'].get('message'):  # pragma: no branch
             for item in message['content']:
+                if reasoning_content := item.get('reasoningContent'):
+                    reasoning_text = reasoning_content.get('reasoningText')
+                    if reasoning_text:  # pragma: no branch
+                        thinking_part = ThinkingPart(content=reasoning_text['text'])
+                        if reasoning_signature := reasoning_text.get('signature'):
+                            thinking_part.signature = reasoning_signature
+                        items.append(thinking_part)
                 if text := item.get('text'):
                     items.append(TextPart(content=text))
-                else:
-                    tool_use = item.get('toolUse')
-                    assert tool_use is not None, f'Found a content that is not a text or tool use: {item}'
+                elif tool_use := item.get('toolUse'):
                     items.append(
                         ToolCallPart(
                             tool_name=tool_use['name'],
@@ -385,7 +392,7 @@ class BedrockConverseModel(Model):
 
         return tool_config
 
-    async def _map_messages(
+    async def _map_messages(  # noqa: C901
         self, messages: list[ModelMessage]
     ) -> tuple[list[SystemContentBlockTypeDef], list[MessageUnionTypeDef]]:
         """Maps a `pydantic_ai.Message` to the Bedrock `MessageUnionTypeDef`.
@@ -448,6 +455,9 @@ class BedrockConverseModel(Model):
                 for item in message.parts:
                     if isinstance(item, TextPart):
                         content.append({'text': item.content})
+                    elif isinstance(item, ThinkingPart):
+                        # NOTE: We don't pass the thinking part to Bedrock since it raises an error.
+                        pass
                     else:
                         assert isinstance(item, ToolCallPart)
                         content.append(self._map_tool_call(item))
@@ -592,6 +602,15 @@ class BedrockStreamedResponse(StreamedResponse):
             if 'contentBlockDelta' in chunk:
                 index = chunk['contentBlockDelta']['contentBlockIndex']
                 delta = chunk['contentBlockDelta']['delta']
+                if 'reasoningContent' in delta:
+                    if text := delta['reasoningContent'].get('text'):
+                        yield self._parts_manager.handle_thinking_delta(vendor_part_id=index, content=text)
+                    else:  # pragma: no cover
+                        warnings.warn(
+                            f'Only text reasoning content is supported yet, but you got {delta["reasoningContent"]}. '
+                            'Please report this to the maintainers.',
+                            UserWarning,
+                        )
                 if 'text' in delta:
                     yield self._parts_manager.handle_text_delta(vendor_part_id=index, content=delta['text'])
                 if 'toolUse' in delta:

pydantic_ai/models/cohere.py

@@ -6,6 +6,8 @@ from typing import Literal, Union, cast
 
 from typing_extensions import assert_never
 
+from pydantic_ai._thinking_part import split_content_into_text_and_thinking
+
 from .. import ModelHTTPError, usage
 from .._utils import generate_tool_call_id as _generate_tool_call_id, guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
@@ -16,6 +18,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -187,7 +190,7 @@ class CohereModel(Model):
             # While Cohere's API returns a list, it only does that for future proofing
             # and currently only one item is being returned.
             choice = response.message.content[0]
-            parts.append(TextPart(choice.text))
+            parts.extend(split_content_into_text_and_thinking(choice.text))
         for c in response.message.tool_calls or []:
             if c.function and c.function.name and c.function.arguments:  # pragma: no branch
                 parts.append(
@@ -211,6 +214,11 @@ class CohereModel(Model):
                 for item in message.parts:
                     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
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
                     else:

pydantic_ai/models/function.py

@@ -24,6 +24,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserContent,
@@ -268,6 +269,10 @@ def _estimate_usage(messages: Iterable[ModelMessage]) -> usage.Usage:
             for part in message.parts:
                 if isinstance(part, TextPart):
                     response_tokens += _estimate_string_tokens(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.
+                    pass
                 elif isinstance(part, ToolCallPart):
                     call = part
                     response_tokens += 1 + _estimate_string_tokens(call.args_as_json_str())

pydantic_ai/models/gemini.py

@@ -27,6 +27,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -94,6 +95,15 @@ class GeminiModelSettings(ModelSettings, total=False):
     See the [Gemini API docs](https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/add-labels-to-api-calls) for use cases and limitations.
     """
 
+    gemini_thinking_config: ThinkingConfig
+    """Thinking is on by default in both the API and AI Studio.
+
+    Being on by default doesn't mean the model will send back thoughts. For that, you need to set `include_thoughts`
+    to `True`. If you want to turn it off, set `thinking_budget` to `0`.
+
+    See more about it on <https://ai.google.dev/gemini-api/docs/thinking>.
+    """
+
 
 @dataclass(init=False)
 class GeminiModel(Model):
@@ -379,7 +389,7 @@ def _settings_to_generation_config(model_settings: GeminiModelSettings) -> _Gemi
     if (frequency_penalty := model_settings.get('frequency_penalty')) is not None:
         config['frequency_penalty'] = frequency_penalty
     if (thinkingConfig := model_settings.get('gemini_thinking_config')) is not None:
-        config['thinking_config'] = thinkingConfig  # pragma: no cover
+        config['thinking_config'] = thinkingConfig  # pragma: lax no cover
     return config
 
 
@@ -576,6 +586,11 @@ def _content_model_response(m: ModelResponse) -> _GeminiContent:
     for item in m.parts:
         if isinstance(item, ToolCallPart):
             parts.append(_function_call_part_from_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.
+            # parts.append(_GeminiTextPart(text=item.content, thought=True))
+            pass
         elif isinstance(item, TextPart):
             if item.content:
                 parts.append(_GeminiTextPart(text=item.content))
@@ -584,29 +599,34 @@ def _content_model_response(m: ModelResponse) -> _GeminiContent:
     return _GeminiContent(role='model', parts=parts)
 
 
-class _GeminiTextPart(TypedDict):
+class _BasePart(TypedDict):
+    thought: NotRequired[bool]
+    """Indicates if the part is thought from the model."""
+
+
+class _GeminiTextPart(_BasePart):
     text: str
 
 
-class _GeminiInlineData(TypedDict):
+class _GeminiInlineData(_BasePart):
     data: str
     mime_type: Annotated[str, pydantic.Field(alias='mimeType')]
 
 
-class _GeminiInlineDataPart(TypedDict):
+class _GeminiInlineDataPart(_BasePart):
     """See <https://ai.google.dev/api/caching#Blob>."""
 
     inline_data: Annotated[_GeminiInlineData, pydantic.Field(alias='inlineData')]
 
 
-class _GeminiFileData(TypedDict):
+class _GeminiFileData(_BasePart):
     """See <https://ai.google.dev/api/caching#FileData>."""
 
     file_uri: Annotated[str, pydantic.Field(alias='fileUri')]
     mime_type: Annotated[str, pydantic.Field(alias='mimeType')]
 
 
-class _GeminiFileDataPart(TypedDict):
+class _GeminiFileDataPart(_BasePart):
     file_data: Annotated[_GeminiFileData, pydantic.Field(alias='fileData')]
 
 
@@ -615,7 +635,7 @@ class _GeminiThoughtPart(TypedDict):
     thought_signature: Annotated[str, pydantic.Field(alias='thoughtSignature')]
 
 
-class _GeminiFunctionCallPart(TypedDict):
+class _GeminiFunctionCallPart(_BasePart):
     function_call: Annotated[_GeminiFunctionCall, pydantic.Field(alias='functionCall')]
 
 
@@ -633,7 +653,12 @@ def _process_response_from_parts(
     items: list[ModelResponsePart] = []
     for part in parts:
         if 'text' in part:
-            items.append(TextPart(content=part['text']))
+            # NOTE: Google doesn't include the `thought` field anymore. We handle this here in case they decide to
+            # change their mind and start including it again.
+            if part.get('thought'):  # pragma: no cover
+                items.append(ThinkingPart(content=part['text']))
+            else:
+                items.append(TextPart(content=part['text']))
         elif 'function_call' in part:
             items.append(ToolCallPart(tool_name=part['function_call']['name'], args=part['function_call']['args']))
         elif 'function_response' in part:  # pragma: no cover

pydantic_ai/models/google.py

@@ -23,6 +23,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -413,7 +414,10 @@ class GeminiStreamedResponse(StreamedResponse):
             assert candidate.content.parts is not None
             for part in candidate.content.parts:
                 if part.text is not None:
-                    yield self._parts_manager.handle_text_delta(vendor_part_id='content', content=part.text)
+                    if part.thought:
+                        yield self._parts_manager.handle_thinking_delta(vendor_part_id='thinking', content=part.text)
+                    else:
+                        yield self._parts_manager.handle_text_delta(vendor_part_id='content', content=part.text)
                 elif part.function_call:
                     maybe_event = self._parts_manager.handle_tool_call_delta(
                         vendor_part_id=uuid4(),
@@ -446,6 +450,11 @@ def _content_model_response(m: ModelResponse) -> ContentDict:
         elif isinstance(item, TextPart):
             if item.content:  # pragma: no branch
                 parts.append({'text': item.content})
+        elif isinstance(item, ThinkingPart):  # pragma: no cover
+            # 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.
+            # parts.append({'text': item.content, 'thought': True})
+            pass
         else:
             assert_never(item)
     return ContentDict(role='model', parts=parts)
@@ -461,7 +470,10 @@ def _process_response_from_parts(
     items: list[ModelResponsePart] = []
     for part in parts:
         if part.text is not None:
-            items.append(TextPart(content=part.text))
+            if part.thought:
+                items.append(ThinkingPart(content=part.text))
+            else:
+                items.append(TextPart(content=part.text))
         elif part.function_call:
             assert part.function_call.name is not None
             tool_call_part = ToolCallPart(tool_name=part.function_call.name, args=part.function_call.args)

pydantic_ai/models/groq.py

@@ -9,6 +9,8 @@ from typing import Literal, Union, cast, overload
 
 from typing_extensions import assert_never
 
+from pydantic_ai._thinking_part import split_content_into_text_and_thinking
+
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id, number_to_datetime
 from ..messages import (
@@ -23,6 +25,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -95,7 +98,7 @@ class GroqModelSettings(ModelSettings, total=False):
     ALL FIELDS MUST BE `groq_` PREFIXED SO YOU CAN MERGE THEM WITH OTHER MODELS.
     """
 
-    # This class is a placeholder for any future groq-specific settings
+    groq_reasoning_format: Literal['hidden', 'raw', 'parsed']
 
 
 @dataclass(init=False)
@@ -234,6 +237,7 @@ class GroqModel(Model):
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 seed=model_settings.get('seed', NOT_GIVEN),
                 presence_penalty=model_settings.get('presence_penalty', NOT_GIVEN),
+                reasoning_format=model_settings.get('groq_reasoning_format', NOT_GIVEN),
                 frequency_penalty=model_settings.get('frequency_penalty', NOT_GIVEN),
                 logit_bias=model_settings.get('logit_bias', NOT_GIVEN),
                 extra_headers=extra_headers,
@@ -249,8 +253,12 @@ class GroqModel(Model):
         timestamp = number_to_datetime(response.created)
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
+        # NOTE: The `reasoning` field is only present if `groq_reasoning_format` is set to `parsed`.
+        if choice.message.reasoning is not None:
+            items.append(ThinkingPart(content=choice.message.reasoning))
         if choice.message.content is not None:
-            items.append(TextPart(content=choice.message.content))
+            # NOTE: The `<think>` tag is only present if `groq_reasoning_format` is set to `raw`.
+            items.extend(split_content_into_text_and_thinking(choice.message.content))
         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))
@@ -293,6 +301,9 @@ class GroqModel(Model):
                         texts.append(item.content)
                     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
                     else:
                         assert_never(item)
                 message_param = chat.ChatCompletionAssistantMessageParam(role='assistant')

pydantic_ai/models/instrumented.py

@@ -134,7 +134,7 @@ class InstrumentationSettings:
                 **tokens_histogram_kwargs,
                 explicit_bucket_boundaries_advisory=TOKEN_HISTOGRAM_BOUNDARIES,
             )
-        except TypeError:
+        except TypeError:  # pragma: lax no cover
             # Older OTel/logfire versions don't support explicit_bucket_boundaries_advisory
             self.tokens_histogram = self.meter.create_histogram(
                 **tokens_histogram_kwargs,  # pyright: ignore

pydantic_ai/models/mistral.py

@@ -11,6 +11,8 @@ import pydantic_core
 from httpx import Timeout
 from typing_extensions import assert_never
 
+from pydantic_ai._thinking_part import split_content_into_text_and_thinking
+
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
 from .._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc, number_to_datetime
 from ..messages import (
@@ -25,6 +27,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -322,7 +325,7 @@ class MistralModel(Model):
 
         parts: list[ModelResponsePart] = []
         if text := _map_content(content):
-            parts.append(TextPart(content=text))
+            parts.extend(split_content_into_text_and_thinking(text))
 
         if isinstance(tool_calls, list):
             for tool_call in tool_calls:
@@ -484,6 +487,11 @@ class MistralModel(Model):
                 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
                     elif isinstance(part, ToolCallPart):
                         tool_calls.append(self._map_tool_call(part))
                     else:

pydantic_ai/models/openai.py

@@ -10,6 +10,7 @@ from typing import Any, Literal, Union, cast, overload
 
 from typing_extensions import assert_never
 
+from pydantic_ai._thinking_part import split_content_into_text_and_thinking
 from pydantic_ai.profiles.openai import OpenAIModelProfile
 from pydantic_ai.providers import Provider, infer_provider
 
@@ -28,6 +29,7 @@ from ..messages import (
     RetryPromptPart,
     SystemPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
     UserPromptPart,
@@ -137,6 +139,9 @@ class OpenAIResponsesModelSettings(OpenAIModelSettings, total=False):
     """
 
     openai_reasoning_generate_summary: Literal['detailed', 'concise']
+    """Deprecated alias for `openai_reasoning_summary`."""
+
+    openai_reasoning_summary: Literal['detailed', 'concise']
     """A summary of the reasoning performed by the model.
 
     This can be useful for debugging and understanding the model's reasoning process.
@@ -325,6 +330,10 @@ class OpenAIModel(Model):
         timestamp = number_to_datetime(response.created)
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
+        # The `reasoning_content` is only present in DeepSeek models.
+        if reasoning_content := getattr(choice.message, 'reasoning_content', None):
+            items.append(ThinkingPart(content=reasoning_content))
+
         vendor_details: dict[str, Any] | None = None
 
         # Add logprobs to vendor_details if available
@@ -345,7 +354,7 @@ class OpenAIModel(Model):
             }
 
         if choice.message.content is not None:
-            items.append(TextPart(choice.message.content))
+            items.extend(split_content_into_text_and_thinking(choice.message.content))
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
                 part = ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id)
@@ -394,6 +403,11 @@ class OpenAIModel(Model):
                 for item in message.parts:
                     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
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
                     else:
@@ -611,7 +625,12 @@ class OpenAIResponsesModel(Model):
         items: list[ModelResponsePart] = []
         items.append(TextPart(response.output_text))
         for item in response.output:
-            if item.type == 'function_call':
+            if item.type == 'reasoning':
+                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 == 'function_call':
                 items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
         return ModelResponse(
             items,
@@ -710,11 +729,22 @@ class OpenAIResponsesModel(Model):
 
     def _get_reasoning(self, model_settings: OpenAIResponsesModelSettings) -> Reasoning | NotGiven:
         reasoning_effort = model_settings.get('openai_reasoning_effort', None)
+        reasoning_summary = model_settings.get('openai_reasoning_summary', None)
         reasoning_generate_summary = model_settings.get('openai_reasoning_generate_summary', None)
 
-        if reasoning_effort is None and reasoning_generate_summary is None:
+        if reasoning_summary and reasoning_generate_summary:  # pragma: no cover
+            raise ValueError('`openai_reasoning_summary` and `openai_reasoning_generate_summary` cannot both be set.')
+
+        if reasoning_generate_summary is not None:  # pragma: no cover
+            warnings.warn(
+                '`openai_reasoning_generate_summary` is deprecated, use `openai_reasoning_summary` instead',
+                DeprecationWarning,
+            )
+            reasoning_summary = reasoning_generate_summary
+
+        if reasoning_effort is None and reasoning_summary is None:
             return NOT_GIVEN
-        return Reasoning(effort=reasoning_effort, generate_summary=reasoning_generate_summary)
+        return Reasoning(effort=reasoning_effort, summary=reasoning_summary)
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[responses.FunctionToolParam]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
@@ -770,11 +800,30 @@ class OpenAIResponsesModel(Model):
                     else:
                         assert_never(part)
             elif isinstance(message, ModelResponse):
+                # last_thinking_part_idx: int | 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))
+                    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
                     else:
                         assert_never(item)
             else:
@@ -948,13 +997,43 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                         vendor_part_id=chunk.item.id,
                         tool_name=chunk.item.name,
                         args=chunk.item.arguments,
-                        tool_call_id=chunk.item.id,
+                        tool_call_id=chunk.item.call_id,
+                    )
+                elif isinstance(chunk.item, responses.ResponseReasoningItem):
+                    content = chunk.item.summary[0].text if chunk.item.summary else ''
+                    yield self._parts_manager.handle_thinking_delta(
+                        vendor_part_id=chunk.item.id,
+                        content=content,
+                        signature=chunk.item.id,
+                    )
+                elif isinstance(chunk.item, responses.ResponseOutputMessage):
+                    pass
+                else:
+                    warnings.warn(  # pragma: no cover
+                        f'Handling of this item type is not yet implemented. Please report on our GitHub: {chunk}',
+                        UserWarning,
                     )
 
             elif isinstance(chunk, responses.ResponseOutputItemDoneEvent):
                 # NOTE: We only need this if the tool call deltas don't include the final info.
                 pass
 
+            elif isinstance(chunk, responses.ResponseReasoningSummaryPartAddedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseReasoningSummaryPartDoneEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseReasoningSummaryTextDoneEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseReasoningSummaryTextDeltaEvent):
+                yield self._parts_manager.handle_thinking_delta(
+                    vendor_part_id=chunk.item_id,
+                    content=chunk.delta,
+                    signature=chunk.item_id,
+                )
+
             elif isinstance(chunk, responses.ResponseTextDeltaEvent):
                 yield self._parts_manager.handle_text_delta(vendor_part_id=chunk.content_index, content=chunk.delta)
 

pydantic_ai/models/test.py

@@ -9,6 +9,7 @@ from datetime import date, datetime, timedelta
 from typing import Any, Literal
 
 import pydantic_core
+from typing_extensions import assert_never
 
 from .. import _utils
 from ..messages import (
@@ -19,17 +20,14 @@ from ..messages import (
     ModelResponseStreamEvent,
     RetryPromptPart,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
 )
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from ..usage import Usage
-from . import (
-    Model,
-    ModelRequestParameters,
-    StreamedResponse,
-)
+from . import Model, ModelRequestParameters, StreamedResponse
 from .function import _estimate_string_tokens, _estimate_usage  # pyright: ignore[reportPrivateUsage]
 
 
@@ -254,10 +252,15 @@ class TestStreamedResponse(StreamedResponse):
                 for word in words:
                     self._usage += _get_string_usage(word)
                     yield self._parts_manager.handle_text_delta(vendor_part_id=i, content=word)
-            else:
+            elif isinstance(part, ToolCallPart):
                 yield self._parts_manager.handle_tool_call_part(
                     vendor_part_id=i, tool_name=part.tool_name, args=part.args, tool_call_id=part.tool_call_id
                 )
+            elif isinstance(part, ThinkingPart):  # pragma: no cover
+                # NOTE: There's no way to reach this part of the code, since we don't generate ThinkingPart on TestModel.
+                assert False, "This should be unreachable — we don't generate ThinkingPart on TestModel."
+            else:
+                assert_never(part)
 
     @property
     def model_name(self) -> str:

{pydantic_ai_slim-0.2.20.dist-info → pydantic_ai_slim-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.2.20
+Version: 0.3.0
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT
@@ -30,15 +30,15 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.2.20
+Requires-Dist: pydantic-graph==0.3.0
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.2.20; extra == 'a2a'
+Requires-Dist: fasta2a==0.3.0; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.52.0; extra == 'anthropic'
 Provides-Extra: bedrock
-Requires-Dist: boto3>=1.35.74; extra == 'bedrock'
+Requires-Dist: boto3>=1.37.24; extra == 'bedrock'
 Provides-Extra: cli
 Requires-Dist: argcomplete>=3.5.0; extra == 'cli'
 Requires-Dist: prompt-toolkit>=3; extra == 'cli'
@@ -48,11 +48,11 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.2.20; extra == 'evals'
+Requires-Dist: pydantic-evals==0.3.0; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: groq
-Requires-Dist: groq>=0.15.0; extra == 'groq'
+Requires-Dist: groq>=0.19.0; extra == 'groq'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Provides-Extra: mcp
@@ -60,7 +60,7 @@ Requires-Dist: mcp>=1.9.4; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.75.0; extra == 'openai'
+Requires-Dist: openai>=1.76.0; extra == 'openai'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai

{pydantic_ai_slim-0.2.20.dist-info → pydantic_ai_slim-0.3.0.dist-info}/RECORD

@@ -1,13 +1,14 @@
 pydantic_ai/__init__.py,sha256=5flxyMQJVrHRMQ3MYaZf1el2ctNs0JmPClKbw2Q-Lsk,1160
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
 pydantic_ai/_a2a.py,sha256=8nNtx6GENDt2Ej3f1ui9L-FuNQBYVELpJFfwz-y7fUw,7234
-pydantic_ai/_agent_graph.py,sha256=ZDXFG1zNlj9_n3_YYR7JTN9d0Eiqlx8viojaXCePeMk,39142
+pydantic_ai/_agent_graph.py,sha256=8Y1xEFwNCp0hVsRst_2I4WQymeTFRJ4Ec5-lURMd5HQ,39671
 pydantic_ai/_cli.py,sha256=kc9UxGjYsKK0IR4No-V5BGiAtq2fY6eZZ9rBkAdHWOM,12948
 pydantic_ai/_function_schema.py,sha256=VXHGnudrpyW40UJqCopgSUB_IuSip5pEEBSLGhVEuFI,10846
 pydantic_ai/_griffe.py,sha256=Sf_DisE9k2TA0VFeVIK2nf1oOct5MygW86PBCACJkFA,5244
 pydantic_ai/_output.py,sha256=HYhcaqcisU16PT_EFdl2VuV5MI-nRFbUPzijd_rTTgM,16787
-pydantic_ai/_parts_manager.py,sha256=c0Gj29FH8K20AmxIr7MY8_SQVdb7SRIRcJYTQVmVYgc,12204
+pydantic_ai/_parts_manager.py,sha256=Lioi8b7Nfyax09yQu8jTkMzxd26dYDrdAqhYvjRSKqQ,16182
 pydantic_ai/_system_prompt.py,sha256=W5wYN6rH5JCshl1xI2s0ygevBCutCraqyG6t75yZubk,1117
+pydantic_ai/_thinking_part.py,sha256=mzx2RZSfiQxAKpljEflrcXRXmFKxtp6bKVyorY3UYZk,1554
 pydantic_ai/_utils.py,sha256=qi2NjYpIVOgCHDMPgyV8oUL42Fv2_rLyj8KdOUO5fQU,11319
 pydantic_ai/agent.py,sha256=oNW5ffihOF1Kn13N3GZ9wudyooGxN0O3r1wGJAwYUMY,94448
 pydantic_ai/direct.py,sha256=tXRcQ3fMkykaawO51VxnSwQnqcEmu1LhCy7U9gOyM-g,7768
@@ -15,7 +16,7 @@ pydantic_ai/exceptions.py,sha256=IdFw594Ou7Vn4YFa7xdZ040_j_6nmyA3MPANbC7sys4,317
 pydantic_ai/format_as_xml.py,sha256=IINfh1evWDphGahqHNLBArB5dQ4NIqS3S-kru35ztGg,372
 pydantic_ai/format_prompt.py,sha256=qdKep95Sjlr7u1-qag4JwPbjoURbG0GbeU_l5ODTNw4,4466
 pydantic_ai/mcp.py,sha256=OkbwSBODgeC4BX2QIvTmECZJbeSYtjZ15ZPnEyf95UI,20157
-pydantic_ai/messages.py,sha256=UraSZP4yTSQa0UnFfBrnD5m80GXNY1hf6YE72F5wz4A,33350
+pydantic_ai/messages.py,sha256=Z8cNpaEcMgdJpyE9ydBLBDJV0A-Hf-GllLAWeUKY4_0,36124
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=YlcR0QAQIejz3fbZ50zYfHKIZco0dwmnZTxytV-n3oM,24609
 pydantic_ai/settings.py,sha256=eRJs2fI2yaIrhtYRlWqKlC9KnFaJHvslgSll8NQ20jc,3533
@@ -27,18 +28,18 @@ pydantic_ai/common_tools/tavily.py,sha256=Q1xxSF5HtXAaZ10Pp-OaDOHXwJf2mco9wScGEQ
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/langchain.py,sha256=TI8B6eBjEGKFfvwyLgC_-0eeba4hDJq7wLZ0OZhbiWw,1967
 pydantic_ai/models/__init__.py,sha256=LhBw4yxIEMByJPthAiWtQwGgNlj3cQkOaX6wtzeMFjA,27947
-pydantic_ai/models/anthropic.py,sha256=E7vVhCkw474aKWTzn5UZOlwEV8xgjeFrjJo9HbcCltc,21402
-pydantic_ai/models/bedrock.py,sha256=OVuPe_gQ1KHzvN9k5w0IZjdY3uGbQ1LqDAeaC9ffBlE,27944
-pydantic_ai/models/cohere.py,sha256=bQLTQguqVXkzkPgWmMncrxApO9CQ7YtgrmFwa057g7g,12116
+pydantic_ai/models/anthropic.py,sha256=s7yvNObBfS-gcXLT0vU8UXjLHITsbr5kkXgP1SYkPms,23832
+pydantic_ai/models/bedrock.py,sha256=67qf_mFnx0kfmKoI96zLOAUn3P47PxPqMrQsaYUrJJ0,29120
+pydantic_ai/models/cohere.py,sha256=UU04-_O-KLgC4DUpM-g4FBPoTOatbmVJJ7mkZNBGsbQ,12626
 pydantic_ai/models/fallback.py,sha256=idOYGMo3CZzpCBT8DDiuPAAgnV2jzluDUq3ESb3KteM,4981
-pydantic_ai/models/function.py,sha256=rnihsyakyieCGbEyxfqzvoBHnR_3LJn4x6DXQqdAAM4,11458
-pydantic_ai/models/gemini.py,sha256=6tjI0aQgzW4i6qtAZzzjDLAkre-mfLywybjaFos8hbA,36199
-pydantic_ai/models/google.py,sha256=ubEHm8PyGziJO0IpPjElPtqbKxc6ZM0F1IBnTt2t1rA,21628
-pydantic_ai/models/groq.py,sha256=rnAwTJ5AXgspqSqi2nJPlqj7sOeZ8H04XNs5cWJqKE4,17816
-pydantic_ai/models/instrumented.py,sha256=DvBNxgkxmMGeUQvBUJUAfRCpgXpJzQhNNe_M5TAVCbw,15679
-pydantic_ai/models/mistral.py,sha256=teNN6IfTTpfZxtSXFdD2M1IDrDj0_EHJt-9gDmAKLvg,29563
-pydantic_ai/models/openai.py,sha256=l1TZ2ZR7zmga2yexGVElbkCGnY35yHSTKU8CQvPRGjQ,44996
-pydantic_ai/models/test.py,sha256=Jlq-YQ9dhzENgmBMVerZpM4L-I2aPf7HH7ifIncyDlE,17010
+pydantic_ai/models/function.py,sha256=xvN_oNKw0X4c16oe1l3MX2_kJtFWMOMaseMNO6eNBYI,11709
+pydantic_ai/models/gemini.py,sha256=d8HY9nc-tcuWFmA5OdKsWABMTpXq68sUL6xE8zY6dzs,37383
+pydantic_ai/models/google.py,sha256=AVXC3CPG1aduGXSc0XFEYnrT6LsNKfNWp-kmf1SQssg,22294
+pydantic_ai/models/groq.py,sha256=lojKRdvg0p-EtZ20Z2CS4I0goq4CoGkLj3LuYHA6o-I,18497
+pydantic_ai/models/instrumented.py,sha256=vVq7mS071EXS2PZ3NJ4Zgt93iQgAscFr2dyg9fAeuCE,15703
+pydantic_ai/models/mistral.py,sha256=LHm3F2yVKoE1uDjEPtTPug6duHwr4A42qey2Pncqqx4,30093
+pydantic_ai/models/openai.py,sha256=onyJSKCo5zj_VY22RTQnPRE0Bpxu1ojgtftveQF_VQc,49633
+pydantic_ai/models/test.py,sha256=X5QVCsBAWXxw4MKet-UTGZ0FteUnCHoK3Py3ngJM2Zk,17437
 pydantic_ai/models/wrapper.py,sha256=43ntRkTF7rVBYLC-Ihdo1fkwpeveOpA_1fXe1fd3W9Y,1690
 pydantic_ai/profiles/__init__.py,sha256=uO_f1kSqrnXuO0x5U0EHTTMRYcmOiOoa-tS1OZppxBk,1426
 pydantic_ai/profiles/_json_schema.py,sha256=3ofRGnBca9WzqlUbw0C1ywhv_V7eGTmFAf2O7Bs5zgk,7199
@@ -69,8 +70,8 @@ pydantic_ai/providers/mistral.py,sha256=EIUSENjFuGzBhvbdrarUTM4VPkesIMnZrzfnEKHO
 pydantic_ai/providers/openai.py,sha256=7iGij0EaFylab7dTZAZDgXr78tr-HsZrn9EI9AkWBNQ,3091
 pydantic_ai/providers/openrouter.py,sha256=NXjNdnlXIBrBMMqbzcWQnowXOuZh4NHikXenBn5h3mc,4061
 pydantic_ai/providers/together.py,sha256=zFVSMSm5jXbpkNouvBOTjWrPmlPpCp6sQS5LMSyVjrQ,3482
-pydantic_ai_slim-0.2.20.dist-info/METADATA,sha256=hni_XHSMACXOSmxZ0B1__3CM4FoWm_Wp0-NZ1PNlz7w,3850
-pydantic_ai_slim-0.2.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.2.20.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.2.20.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.2.20.dist-info/RECORD,,
+pydantic_ai_slim-0.3.0.dist-info/METADATA,sha256=GmMBkJvakRA_lUHh_jO941_uxk5JwGKgWNle0dLCAOQ,3846
+pydantic_ai_slim-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.3.0.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.3.0.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.3.0.dist-info/RECORD,,