pydantic-ai-slim 0.2.20__tar.gz → 0.3.0__tar.gz

{pydantic_ai_slim-0.2.20 → pydantic_ai_slim-0.3.0}/PKG-INFO

@@ -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 → pydantic_ai_slim-0.3.0}/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_slim-0.2.20 → pydantic_ai_slim-0.3.0}/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_slim-0.3.0/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_slim-0.2.20 → pydantic_ai_slim-0.3.0}/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_slim-0.2.20 → pydantic_ai_slim-0.3.0}/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_slim-0.2.20 → pydantic_ai_slim-0.3.0}/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_slim-0.2.20 → pydantic_ai_slim-0.3.0}/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_slim-0.2.20 → pydantic_ai_slim-0.3.0}/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())