pydantic-ai-slim 1.0.4__tar.gz → 1.0.6__tar.gz

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/.gitignore

@@ -20,3 +20,4 @@ node_modules/
 .coverage*
 /test_tmp/
 .mcp.json
+.claude/

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.4
+Version: 1.0.6
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
 Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
@@ -33,7 +33,7 @@ Requires-Dist: genai-prices>=0.0.23
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.0.4
+Requires-Dist: pydantic-graph==1.0.6
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -51,13 +51,13 @@ Requires-Dist: prompt-toolkit>=3; extra == 'cli'
 Requires-Dist: pyperclip>=1.9.0; extra == 'cli'
 Requires-Dist: rich>=13; extra == 'cli'
 Provides-Extra: cohere
-Requires-Dist: cohere>=5.17.0; (platform_system != 'Emscripten') and extra == 'cohere'
+Requires-Dist: cohere>=5.18.0; (platform_system != 'Emscripten') and extra == 'cohere'
 Provides-Extra: dbos
 Requires-Dist: dbos>=1.13.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.0.4; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.6; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/pydantic_ai/_parts_manager.py

@@ -71,6 +71,7 @@ class ModelResponsePartsManager:
         *,
         vendor_part_id: VendorId | None,
         content: str,
+        id: str | None = None,
         thinking_tags: tuple[str, str] | None = None,
         ignore_leading_whitespace: bool = False,
     ) -> ModelResponseStreamEvent | None:
@@ -85,6 +86,7 @@ class ModelResponsePartsManager:
                 of text. If None, a new part will be created unless the latest part is already
                 a TextPart.
             content: The text content to append to the appropriate TextPart.
+            id: An optional id for the text part.
             thinking_tags: If provided, will handle content between the thinking tags as thinking parts.
             ignore_leading_whitespace: If True, will ignore leading whitespace in the content.
 
@@ -137,7 +139,7 @@ class ModelResponsePartsManager:
 
             # There is no existing text part that should be updated, so create a new one
             new_part_index = len(self._parts)
-            part = TextPart(content=content)
+            part = TextPart(content=content, id=id)
             if vendor_part_id is not None:
                 self._vendor_id_to_part_index[vendor_part_id] = new_part_index
             self._parts.append(part)

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/pydantic_ai/builtin_tools.py

@@ -26,8 +26,9 @@ class WebSearchTool(AbstractBuiltinTool):
     The parameters that PydanticAI passes depend on the model, as some parameters may not be supported by certain models.
 
     Supported by:
+
     * Anthropic
-    * OpenAI
+    * OpenAI Responses
     * Groq
     * Google
     """
@@ -36,15 +37,17 @@ class WebSearchTool(AbstractBuiltinTool):
     """The `search_context_size` parameter controls how much context is retrieved from the web to help the tool formulate a response.
 
     Supported by:
-    * OpenAI
+
+    * OpenAI Responses
     """
 
     user_location: WebSearchUserLocation | None = None
     """The `user_location` parameter allows you to localize search results based on a user's location.
 
     Supported by:
+
     * Anthropic
-    * OpenAI
+    * OpenAI Responses
     """
 
     blocked_domains: list[str] | None = None
@@ -53,8 +56,9 @@ class WebSearchTool(AbstractBuiltinTool):
     With Anthropic, you can only use one of `blocked_domains` or `allowed_domains`, not both.
 
     Supported by:
-    * Anthropic (https://docs.anthropic.com/en/docs/build-with-claude/tool-use/web-search-tool#domain-filtering)
-    * Groq (https://console.groq.com/docs/agentic-tooling#search-settings)
+
+    * Anthropic, see <https://docs.anthropic.com/en/docs/build-with-claude/tool-use/web-search-tool#domain-filtering>
+    * Groq, see <https://console.groq.com/docs/agentic-tooling#search-settings>
     """
 
     allowed_domains: list[str] | None = None
@@ -63,14 +67,16 @@ class WebSearchTool(AbstractBuiltinTool):
     With Anthropic, you can only use one of `blocked_domains` or `allowed_domains`, not both.
 
     Supported by:
-    * Anthropic (https://docs.anthropic.com/en/docs/build-with-claude/tool-use/web-search-tool#domain-filtering)
-    * Groq (https://console.groq.com/docs/agentic-tooling#search-settings)
+
+    * Anthropic, see <https://docs.anthropic.com/en/docs/build-with-claude/tool-use/web-search-tool#domain-filtering>
+    * Groq, see <https://console.groq.com/docs/agentic-tooling#search-settings>
     """
 
     max_uses: int | None = None
     """If provided, the tool will stop searching the web after the given number of uses.
 
     Supported by:
+
     * Anthropic
     """
 
@@ -79,8 +85,9 @@ class WebSearchUserLocation(TypedDict, total=False):
     """Allows you to localize search results based on a user's location.
 
     Supported by:
+
     * Anthropic
-    * OpenAI
+    * OpenAI Responses
     """
 
     city: str
@@ -100,8 +107,9 @@ class CodeExecutionTool(AbstractBuiltinTool):
     """A builtin tool that allows your agent to execute code.
 
     Supported by:
+
     * Anthropic
-    * OpenAI
+    * OpenAI Responses
     * Google
     """
 
@@ -110,5 +118,6 @@ class UrlContextTool(AbstractBuiltinTool):
     """Allows your agent to access contents from URLs.
 
     Supported by:
+
     * Google
     """

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/pydantic_ai/mcp.py

@@ -10,12 +10,14 @@ from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontext
 from dataclasses import field, replace
 from datetime import timedelta
 from pathlib import Path
-from typing import Any
+from typing import Annotated, Any
 
 import anyio
 import httpx
 import pydantic_core
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from pydantic import BaseModel, Discriminator, Field, Tag
+from pydantic_core import CoreSchema, core_schema
 from typing_extensions import Self, assert_never, deprecated
 
 from pydantic_ai.tools import RunContext, ToolDefinition
@@ -41,7 +43,7 @@ except ImportError as _import_error:
 # after mcp imports so any import error maps to this file, not _mcp.py
 from . import _mcp, _utils, exceptions, messages, models
 
-__all__ = 'MCPServer', 'MCPServerStdio', 'MCPServerHTTP', 'MCPServerSSE', 'MCPServerStreamableHTTP'
+__all__ = 'MCPServer', 'MCPServerStdio', 'MCPServerHTTP', 'MCPServerSSE', 'MCPServerStreamableHTTP', 'load_mcp_servers'
 
 TOOL_SCHEMA_VALIDATOR = pydantic_core.SchemaValidator(
     schema=pydantic_core.core_schema.dict_schema(
@@ -498,6 +500,22 @@ class MCPServerStdio(MCPServer):
             id=id,
         )
 
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _: Any, __: Any) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            lambda dct: MCPServerStdio(**dct),
+            core_schema.typed_dict_schema(
+                {
+                    'command': core_schema.typed_dict_field(core_schema.str_schema()),
+                    'args': core_schema.typed_dict_field(core_schema.list_schema(core_schema.str_schema())),
+                    'env': core_schema.typed_dict_field(
+                        core_schema.dict_schema(core_schema.str_schema(), core_schema.str_schema()),
+                        required=False,
+                    ),
+                }
+            ),
+        )
+
     @asynccontextmanager
     async def client_streams(
         self,
@@ -520,6 +538,16 @@ class MCPServerStdio(MCPServer):
             repr_args.append(f'id={self.id!r}')
         return f'{self.__class__.__name__}({", ".join(repr_args)})'
 
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, MCPServerStdio):
+            return False  # pragma: no cover
+        return (
+            self.command == value.command
+            and self.args == value.args
+            and self.env == value.env
+            and self.cwd == value.cwd
+        )
+
 
 class _MCPServerHTTP(MCPServer):
     url: str
@@ -733,10 +761,29 @@ class MCPServerSSE(_MCPServerHTTP):
     1. This will connect to a server running on `localhost:3001`.
     """
 
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _: Any, __: Any) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            lambda dct: MCPServerSSE(**dct),
+            core_schema.typed_dict_schema(
+                {
+                    'url': core_schema.typed_dict_field(core_schema.str_schema()),
+                    'headers': core_schema.typed_dict_field(
+                        core_schema.dict_schema(core_schema.str_schema(), core_schema.str_schema()), required=False
+                    ),
+                }
+            ),
+        )
+
     @property
     def _transport_client(self):
         return sse_client  # pragma: no cover
 
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, MCPServerSSE):
+            return False  # pragma: no cover
+        return self.url == value.url
+
 
 @deprecated('The `MCPServerHTTP` class is deprecated, use `MCPServerSSE` instead.')
 class MCPServerHTTP(MCPServerSSE):
@@ -790,10 +837,29 @@ class MCPServerStreamableHTTP(_MCPServerHTTP):
     ```
     """
 
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _: Any, __: Any) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            lambda dct: MCPServerStreamableHTTP(**dct),
+            core_schema.typed_dict_schema(
+                {
+                    'url': core_schema.typed_dict_field(core_schema.str_schema()),
+                    'headers': core_schema.typed_dict_field(
+                        core_schema.dict_schema(core_schema.str_schema(), core_schema.str_schema()), required=False
+                    ),
+                }
+            ),
+        )
+
     @property
     def _transport_client(self):
         return streamablehttp_client  # pragma: no cover
 
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, MCPServerStreamableHTTP):
+            return False  # pragma: no cover
+        return self.url == value.url
+
 
 ToolResult = (
     str
@@ -823,3 +889,50 @@ It accepts a run context, the original tool call function, a tool name, and argu
 Allows wrapping an MCP server tool call to customize it, including adding extra request
 metadata.
 """
+
+
+def _mcp_server_discriminator(value: dict[str, Any]) -> str | None:
+    if 'url' in value:
+        if value['url'].endswith('/sse'):
+            return 'sse'
+        return 'streamable-http'
+    return 'stdio'
+
+
+class MCPServerConfig(BaseModel):
+    """Configuration for MCP servers."""
+
+    mcp_servers: Annotated[
+        dict[
+            str,
+            Annotated[
+                Annotated[MCPServerStdio, Tag('stdio')]
+                | Annotated[MCPServerStreamableHTTP, Tag('streamable-http')]
+                | Annotated[MCPServerSSE, Tag('sse')],
+                Discriminator(_mcp_server_discriminator),
+            ],
+        ],
+        Field(alias='mcpServers'),
+    ]
+
+
+def load_mcp_servers(config_path: str | Path) -> list[MCPServerStdio | MCPServerStreamableHTTP | MCPServerSSE]:
+    """Load MCP servers from a configuration file.
+
+    Args:
+        config_path: The path to the configuration file.
+
+    Returns:
+        A list of MCP servers.
+
+    Raises:
+        FileNotFoundError: If the configuration file does not exist.
+        ValidationError: If the configuration file does not match the schema.
+    """
+    config_path = Path(config_path)
+
+    if not config_path.exists():
+        raise FileNotFoundError(f'Config file {config_path} not found')
+
+    config = MCPServerConfig.model_validate_json(config_path.read_bytes())
+    return list(config.mcp_servers.values())

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/pydantic_ai/messages.py

@@ -870,6 +870,9 @@ class TextPart:
 
     _: KW_ONLY
 
+    id: str | None = None
+    """An optional identifier of the text part."""
+
     part_kind: Literal['text'] = 'text'
     """Part type identifier, this is available on all parts as a discriminator."""
 

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/pydantic_ai/models/cohere.py

@@ -207,7 +207,7 @@ class CohereModel(Model):
                 if content.type == 'text':
                     parts.append(TextPart(content=content.text))
                 elif content.type == 'thinking':  # pragma: no branch
-                    parts.append(ThinkingPart(content=cast(str, content.thinking)))  # pyright: ignore[reportUnknownMemberType,reportAttributeAccessIssue] - https://github.com/cohere-ai/cohere-python/issues/692
+                    parts.append(ThinkingPart(content=content.thinking))
         for c in response.message.tool_calls or []:
             if c.function and c.function.name and c.function.arguments:  # pragma: no branch
                 parts.append(
@@ -258,7 +258,7 @@ class CohereModel(Model):
                 if texts or thinking:
                     contents: list[AssistantMessageV2ContentItem] = []
                     if thinking:
-                        contents.append(ThinkingAssistantMessageV2ContentItem(thinking='\n\n'.join(thinking)))  # pyright: ignore[reportCallIssue] - https://github.com/cohere-ai/cohere-python/issues/692
+                        contents.append(ThinkingAssistantMessageV2ContentItem(thinking='\n\n'.join(thinking)))
                     if texts:  # pragma: no branch
                         contents.append(TextAssistantMessageV2ContentItem(text='\n\n'.join(texts)))
                     message_param.content = contents

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/pydantic_ai/models/openai.py

@@ -190,10 +190,19 @@ class OpenAIResponsesModelSettings(OpenAIChatModelSettings, total=False):
     This can be useful for debugging and understanding the model's reasoning process.
     One of `concise` or `detailed`.
 
-    Check the [OpenAI Computer use documentation](https://platform.openai.com/docs/guides/tools-computer-use#1-send-a-request-to-the-model)
+    Check the [OpenAI Reasoning documentation](https://platform.openai.com/docs/guides/reasoning?api-mode=responses#reasoning-summaries)
     for more details.
     """
 
+    openai_send_reasoning_ids: bool
+    """Whether to send reasoning IDs from the message history to the model. Enabled by default.
+
+    This can result in errors like `"Item 'rs_123' of type 'reasoning' was provided without its required following item."`
+    if the message history you're sending does not match exactly what was received from the Responses API in a previous response,
+    for example if you're using a [history processor](../../message-history.md#processing-message-history).
+    In that case, you'll want to disable this.
+    """
+
     openai_truncation: Literal['disabled', 'auto']
     """The truncation strategy to use for the model response.
 
@@ -213,6 +222,17 @@ class OpenAIResponsesModelSettings(OpenAIChatModelSettings, total=False):
     `medium`, and `high`.
     """
 
+    openai_previous_response_id: Literal['auto'] | str
+    """The ID of a previous response from the model to use as the starting point for a continued conversation.
+
+    When set to `'auto'`, the request automatically uses the most recent
+    `provider_response_id` from the message history and omits earlier messages.
+
+    This enables the model to use server-side conversation state and faithfully reference previous reasoning.
+    See the [OpenAI Responses API documentation](https://platform.openai.com/docs/guides/reasoning#keeping-reasoning-items-in-context)
+    for more information.
+    """
+
 
 @dataclass(init=False)
 class OpenAIChatModel(Model):
@@ -859,24 +879,34 @@ class OpenAIResponsesModel(Model):
         for item in response.output:
             if isinstance(item, responses.ResponseReasoningItem):
                 signature = item.encrypted_content
-                for summary in item.summary:
-                    # 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.
+                if item.summary:
+                    for summary in item.summary:
+                        # We use the same id for all summaries so that we can merge them on the round trip.
+                        items.append(
+                            ThinkingPart(
+                                content=summary.text,
+                                id=item.id,
+                                signature=signature,
+                                provider_name=self.system if signature else None,
+                            )
+                        )
+                        # We only need to store the signature once.
+                        signature = None
+                elif signature:
                     items.append(
                         ThinkingPart(
-                            content=summary.text,
+                            content='',
                             id=item.id,
                             signature=signature,
-                            provider_name=self.system if signature else None,
+                            provider_name=self.system,
                         )
                     )
-                    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 isinstance(content, responses.ResponseOutputText):  # pragma: no branch
-                        items.append(TextPart(content.text))
+                        items.append(TextPart(content.text, id=item.id))
             elif isinstance(item, responses.ResponseFunctionToolCall):
                 items.append(
                     ToolCallPart(item.name, item.arguments, tool_call_id=_combine_tool_call_ids(item.call_id, item.id))
@@ -958,7 +988,11 @@ class OpenAIResponsesModel(Model):
         else:
             tool_choice = 'auto'
 
-        instructions, openai_messages = await self._map_messages(messages)
+        previous_response_id = model_settings.get('openai_previous_response_id')
+        if previous_response_id == 'auto':
+            previous_response_id, messages = self._get_previous_response_id_and_new_messages(messages)
+
+        instructions, openai_messages = await self._map_messages(messages, model_settings)
         reasoning = self._get_reasoning(model_settings)
 
         text: responses.ResponseTextConfigParam | None = None
@@ -1008,6 +1042,7 @@ class OpenAIResponsesModel(Model):
                 truncation=model_settings.get('openai_truncation', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),
                 service_tier=model_settings.get('openai_service_tier', NOT_GIVEN),
+                previous_response_id=previous_response_id,
                 reasoning=reasoning,
                 user=model_settings.get('openai_user', NOT_GIVEN),
                 text=text or NOT_GIVEN,
@@ -1073,8 +1108,30 @@ class OpenAIResponsesModel(Model):
             ),
         }
 
-    async def _map_messages(  # noqa: C901
+    def _get_previous_response_id_and_new_messages(
         self, messages: list[ModelMessage]
+    ) -> tuple[str | None, list[ModelMessage]]:
+        # When `openai_previous_response_id` is set to 'auto', the most recent
+        # `provider_response_id` from the message history is selected and all
+        # earlier messages are omitted. This allows the OpenAI SDK to reuse
+        # server-side history for efficiency. The returned tuple contains the
+        # `previous_response_id` (if found) and the trimmed list of messages.
+        previous_response_id = None
+        trimmed_messages: list[ModelMessage] = []
+        for m in reversed(messages):
+            if isinstance(m, ModelResponse) and m.provider_name == self.system:
+                previous_response_id = m.provider_response_id
+                break
+            else:
+                trimmed_messages.append(m)
+
+        if previous_response_id and trimmed_messages:
+            return previous_response_id, list(reversed(trimmed_messages))
+        else:
+            return None, messages
+
+    async def _map_messages(  # noqa: C901
+        self, messages: list[ModelMessage], model_settings: OpenAIResponsesModelSettings
     ) -> tuple[str | NotGiven, list[responses.ResponseInputItemParam]]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.responses.ResponseInputParam`."""
         openai_messages: list[responses.ResponseInputItemParam] = []
@@ -1112,30 +1169,77 @@ class OpenAIResponsesModel(Model):
                     else:
                         assert_never(part)
             elif isinstance(message, ModelResponse):
+                message_item: responses.ResponseOutputMessageParam | 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))
+                        if item.id and message.provider_name == self.system:
+                            if message_item is None or message_item['id'] != item.id:  # pragma: no branch
+                                message_item = responses.ResponseOutputMessageParam(
+                                    role='assistant',
+                                    id=item.id or _utils.generate_tool_call_id(),
+                                    content=[],
+                                    type='message',
+                                    status='completed',
+                                )
+                                openai_messages.append(message_item)
+
+                            message_item['content'] = [
+                                *message_item['content'],
+                                responses.ResponseOutputTextParam(
+                                    text=item.content, type='output_text', annotations=[]
+                                ),
+                            ]
+                        else:
+                            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, BuiltinToolCallPart | BuiltinToolReturnPart):
                         # We don't currently track built-in tool calls from OpenAI
                         pass
                     elif isinstance(item, ThinkingPart):
-                        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)
+                        if (
+                            item.id
+                            and message.provider_name == self.system
+                            and model_settings.get('openai_send_reasoning_ids', True)
+                        ):
+                            signature: str | None = None
+                            if (
+                                item.signature
+                                and item.provider_name == self.system
+                                and OpenAIModelProfile.from_profile(
+                                    self.profile
+                                ).openai_supports_encrypted_reasoning_content
+                            ):
+                                signature = item.signature
+
+                            if (reasoning_item is None or reasoning_item['id'] != item.id) and (
+                                signature or item.content
+                            ):  # pragma: no branch
+                                reasoning_item = responses.ResponseReasoningItemParam(
+                                    id=item.id,
+                                    summary=[],
+                                    encrypted_content=signature,
+                                    type='reasoning',
+                                )
+                                openai_messages.append(reasoning_item)
+
+                            if item.content:
+                                # The check above guarantees that `reasoning_item` is not None
+                                assert reasoning_item is not None
+                                reasoning_item['summary'] = [
+                                    *reasoning_item['summary'],
+                                    Summary(text=item.content, type='summary_text'),
+                                ]
+                        else:
+                            start_tag, end_tag = self.profile.thinking_tags
+                            openai_messages.append(
+                                responses.EasyInputMessageParam(
+                                    role='assistant', content='\n'.join([start_tag, item.content, end_tag])
+                                )
+                            )
                     else:
                         assert_never(item)
             else:
@@ -1391,15 +1495,14 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
 
             elif isinstance(chunk, responses.ResponseOutputItemDoneEvent):
                 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
+                    if signature := chunk.item.encrypted_content:  # pragma: no branch
+                        # Add the signature to the part corresponding to the first summary item
+                        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,
+                        )
 
             elif isinstance(chunk, responses.ResponseReasoningSummaryPartAddedEvent):
                 yield self._parts_manager.handle_thinking_delta(
@@ -1426,7 +1529,9 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                 pass  # there's nothing we need to do here
 
             elif isinstance(chunk, responses.ResponseTextDeltaEvent):
-                maybe_event = self._parts_manager.handle_text_delta(vendor_part_id=chunk.item_id, content=chunk.delta)
+                maybe_event = self._parts_manager.handle_text_delta(
+                    vendor_part_id=chunk.item_id, content=chunk.delta, id=chunk.item_id
+                )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event
 

{pydantic_ai_slim-1.0.4 → pydantic_ai_slim-1.0.6}/pyproject.toml

@@ -68,7 +68,7 @@ dependencies = [
 logfire = ["logfire[httpx]>=3.14.1"]
 # Models
 openai = ["openai>=1.99.9"]
-cohere = ["cohere>=5.17.0; platform_system != 'Emscripten'"]
+cohere = ["cohere>=5.18.0; platform_system != 'Emscripten'"]
 vertexai = ["google-auth>=2.36.0", "requests>=2.32.2"]
 google = ["google-genai>=1.31.0"]
 anthropic = ["anthropic>=0.61.0"]