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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.5
+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.5
+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.5; 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.5 → 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.5 → 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.5 → 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.5 → pydantic_ai_slim-1.0.6}/pydantic_ai/models/openai.py

@@ -222,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):
@@ -977,6 +988,10 @@ class OpenAIResponsesModel(Model):
         else:
             tool_choice = 'auto'
 
+        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)
 
@@ -1027,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,
@@ -1092,6 +1108,28 @@ class OpenAIResponsesModel(Model):
             ),
         }
 
+    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]]:
@@ -1135,7 +1173,7 @@ class OpenAIResponsesModel(Model):
                 reasoning_item: responses.ResponseReasoningItemParam | None = None
                 for item in message.parts:
                     if isinstance(item, TextPart):
-                        if item.id and item.id.startswith('msg_'):
+                        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',
@@ -1164,26 +1202,33 @@ class OpenAIResponsesModel(Model):
                     elif isinstance(item, ThinkingPart):
                         if (
                             item.id
-                            and item.provider_name == self.system
-                            and OpenAIModelProfile.from_profile(
-                                self.profile
-                            ).openai_supports_encrypted_reasoning_content
+                            and message.provider_name == self.system
                             and model_settings.get('openai_send_reasoning_ids', True)
                         ):
+                            signature: str | None = None
                             if (
-                                reasoning_item is None
-                                or reasoning_item['id'] != item.id
-                                and (item.signature or item.content)
+                                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=item.signature,
+                                    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'),

{pydantic_ai_slim-1.0.5 → 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"]