pydantic-ai-slim 0.2.12__tar.gz → 0.2.14__tar.gz

{pydantic_ai_slim-0.2.12 → pydantic_ai_slim-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.2.12
+Version: 0.2.14
 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,11 +30,11 @@ 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.12
+Requires-Dist: pydantic-graph==0.2.14
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.2.12; extra == 'a2a'
+Requires-Dist: fasta2a==0.2.14; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.52.0; extra == 'anthropic'
 Provides-Extra: bedrock
@@ -48,7 +48,7 @@ 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.12; extra == 'evals'
+Requires-Dist: pydantic-evals==0.2.14; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.2.12 → pydantic_ai_slim-0.2.14}/pydantic_ai/_output.py

@@ -407,7 +407,7 @@ class OutputTool(Generic[OutputDataT]):
             if wrap_validation_errors:
                 m = _messages.RetryPromptPart(
                     tool_name=tool_call.tool_name,
-                    content=e.errors(include_url=False),
+                    content=e.errors(include_url=False, include_context=False),
                     tool_call_id=tool_call.tool_call_id,
                 )
                 raise ToolRetryError(m) from e

{pydantic_ai_slim-0.2.12 → pydantic_ai_slim-0.2.14}/pydantic_ai/mcp.py

@@ -6,18 +6,17 @@ from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
-from datetime import timedelta
 from pathlib import Path
 from types import TracebackType
 from typing import Any
 
 import anyio
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from mcp.shared.message import SessionMessage
 from mcp.types import (
     BlobResourceContents,
     EmbeddedResource,
     ImageContent,
+    JSONRPCMessage,
     LoggingLevel,
     TextContent,
     TextResourceContents,
@@ -30,8 +29,8 @@ from pydantic_ai.tools import ToolDefinition
 
 try:
     from mcp.client.session import ClientSession
+    from mcp.client.sse import sse_client
     from mcp.client.stdio import StdioServerParameters, stdio_client
-    from mcp.client.streamable_http import streamablehttp_client
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `mcp` package to use the MCP server, '
@@ -57,8 +56,8 @@ class MCPServer(ABC):
     """
 
     _client: ClientSession
-    _read_stream: MemoryObjectReceiveStream[SessionMessage | Exception]
-    _write_stream: MemoryObjectSendStream[SessionMessage]
+    _read_stream: MemoryObjectReceiveStream[JSONRPCMessage | Exception]
+    _write_stream: MemoryObjectSendStream[JSONRPCMessage]
     _exit_stack: AsyncExitStack
 
     @abstractmethod
@@ -66,7 +65,10 @@ class MCPServer(ABC):
     async def client_streams(
         self,
     ) -> AsyncIterator[
-        tuple[MemoryObjectReceiveStream[SessionMessage | Exception], MemoryObjectSendStream[SessionMessage]]
+        tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
     ]:
         """Create the streams for the MCP server."""
         raise NotImplementedError('MCP Server subclasses must implement this method.')
@@ -263,7 +265,10 @@ class MCPServerStdio(MCPServer):
     async def client_streams(
         self,
     ) -> AsyncIterator[
-        tuple[MemoryObjectReceiveStream[SessionMessage | Exception], MemoryObjectSendStream[SessionMessage]]
+        tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
     ]:
         server = StdioServerParameters(command=self.command, args=list(self.args), env=self.env, cwd=self.cwd)
         async with stdio_client(server=server) as (read_stream, write_stream):
@@ -283,11 +288,11 @@ class MCPServerStdio(MCPServer):
 class MCPServerHTTP(MCPServer):
     """An MCP server that connects over streamable HTTP connections.
 
-    This class implements the Streamable HTTP transport from the MCP specification.
-    See <https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http> for more information.
+    This class implements the SSE transport from the MCP specification.
+    See <https://spec.modelcontextprotocol.io/specification/2024-11-05/basic/transports/#http-with-sse> for more information.
 
-    The Streamable HTTP transport is intended to replace the SSE transport from the previous protocol, but it is fully
-    backwards compatible with SSE-based servers.
+    The name "HTTP" is used since this implemented will be adapted in future to use the new
+    [Streamable HTTP](https://github.com/modelcontextprotocol/specification/pull/206) currently in development.
 
     !!! note
         Using this class as an async context manager will create a new pool of HTTP connections to connect
@@ -298,7 +303,7 @@ class MCPServerHTTP(MCPServer):
     from pydantic_ai import Agent
     from pydantic_ai.mcp import MCPServerHTTP
 
-    server = MCPServerHTTP('http://localhost:3001/mcp')  # (1)!
+    server = MCPServerHTTP('http://localhost:3001/sse')  # (1)!
     agent = Agent('openai:gpt-4o', mcp_servers=[server])
 
     async def main():
@@ -311,13 +316,13 @@ class MCPServerHTTP(MCPServer):
     """
 
     url: str
-    """The URL of the SSE or MCP endpoint on the MCP server.
+    """The URL of the SSE endpoint on the MCP server.
 
-    For example for a server running locally, this might be `http://localhost:3001/mcp`.
+    For example for a server running locally, this might be `http://localhost:3001/sse`.
     """
 
     headers: dict[str, Any] | None = None
-    """Optional HTTP headers to be sent with each request to the endpoint.
+    """Optional HTTP headers to be sent with each request to the SSE endpoint.
 
     These headers will be passed directly to the underlying `httpx.AsyncClient`.
     Useful for authentication, custom headers, or other HTTP-specific configurations.
@@ -330,8 +335,8 @@ class MCPServerHTTP(MCPServer):
     If the connection cannot be established within this time, the operation will fail.
     """
 
-    sse_read_timeout: float = 300
-    """Maximum time as in seconds to wait for new SSE messages before timing out.
+    sse_read_timeout: float = 5 * 60
+    """Maximum time in seconds to wait for new SSE messages before timing out.
 
     This timeout applies to the long-lived SSE connection after it's established.
     If no new messages are received within this time, the connection will be considered stale
@@ -353,28 +358,21 @@ class MCPServerHTTP(MCPServer):
     For example, if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
     """
 
-    def __post_init__(self):
-        # streamablehttp_client expects timedeltas, so we accept them too to match,
-        # but primarily work with floats for a simpler user API.
-
-        if isinstance(self.timeout, timedelta):
-            self.timeout = self.timeout.total_seconds()
-
-        if isinstance(self.sse_read_timeout, timedelta):
-            self.sse_read_timeout = self.sse_read_timeout.total_seconds()
-
     @asynccontextmanager
     async def client_streams(
         self,
     ) -> AsyncIterator[
-        tuple[MemoryObjectReceiveStream[SessionMessage | Exception], MemoryObjectSendStream[SessionMessage]]
+        tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
     ]:  # pragma: no cover
-        async with streamablehttp_client(
+        async with sse_client(
             url=self.url,
             headers=self.headers,
-            timeout=timedelta(seconds=self.timeout),
-            sse_read_timeout=timedelta(seconds=self.sse_read_timeout),
-        ) as (read_stream, write_stream, _):
+            timeout=self.timeout,
+            sse_read_timeout=self.sse_read_timeout,
+        ) as (read_stream, write_stream):
             yield read_stream, write_stream
 
     def _get_log_level(self) -> LoggingLevel | None:

{pydantic_ai_slim-0.2.12 → pydantic_ai_slim-0.2.14}/pydantic_ai/models/gemini.py

@@ -431,7 +431,8 @@ class GeminiStreamedResponse(StreamedResponse):
                     if maybe_event is not None:  # pragma: no branch
                         yield maybe_event
                 else:
-                    assert 'function_response' in gemini_part, f'Unexpected part: {gemini_part}'  # pragma: no cover
+                    if not any([key in gemini_part for key in ['function_response', 'thought']]):
+                        raise AssertionError(f'Unexpected part: {gemini_part}')  # pragma: no cover
 
     async def _get_gemini_responses(self) -> AsyncIterator[_GeminiResponse]:
         # This method exists to ensure we only yield completed items, so we don't need to worry about
@@ -605,6 +606,11 @@ class _GeminiFileDataPart(TypedDict):
     file_data: Annotated[_GeminiFileData, pydantic.Field(alias='fileData')]
 
 
+class _GeminiThoughtPart(TypedDict):
+    thought: bool
+    thought_signature: Annotated[str, pydantic.Field(alias='thoughtSignature')]
+
+
 class _GeminiFunctionCallPart(TypedDict):
     function_call: Annotated[_GeminiFunctionCall, pydantic.Field(alias='functionCall')]
 
@@ -665,6 +671,8 @@ def _part_discriminator(v: Any) -> str:
             return 'inline_data'  # pragma: no cover
         elif 'fileData' in v:
             return 'file_data'  # pragma: no cover
+        elif 'thought' in v:
+            return 'thought'
         elif 'functionCall' in v or 'function_call' in v:
             return 'function_call'
         elif 'functionResponse' in v or 'function_response' in v:
@@ -682,6 +690,7 @@ _GeminiPartUnion = Annotated[
         Annotated[_GeminiFunctionResponsePart, pydantic.Tag('function_response')],
         Annotated[_GeminiInlineDataPart, pydantic.Tag('inline_data')],
         Annotated[_GeminiFileDataPart, pydantic.Tag('file_data')],
+        Annotated[_GeminiThoughtPart, pydantic.Tag('thought')],
     ],
     pydantic.Discriminator(_part_discriminator),
 ]

{pydantic_ai_slim-0.2.12 → pydantic_ai_slim-0.2.14}/pydantic_ai/models/google.py

@@ -399,7 +399,7 @@ class GeminiStreamedResponse(StreamedResponse):
                 raise UnexpectedModelBehavior('Streamed response has no content field')  # pragma: no cover
             assert candidate.content.parts is not None
             for part in candidate.content.parts:
-                if part.text:
+                if part.text is not None:
                     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(
@@ -447,7 +447,7 @@ def _process_response_from_parts(
 ) -> ModelResponse:
     items: list[ModelResponsePart] = []
     for part in parts:
-        if part.text:
+        if part.text is not None:
             items.append(TextPart(content=part.text))
         elif part.function_call:
             assert part.function_call.name is not None

{pydantic_ai_slim-0.2.12 → pydantic_ai_slim-0.2.14}/pydantic_ai/models/openai.py

@@ -334,7 +334,9 @@ class OpenAIModel(Model):
             items.append(TextPart(choice.message.content))
         if choice.message.tool_calls is not None:
             for c in choice.message.tool_calls:
-                items.append(ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id))
+                part = ToolCallPart(c.function.name, c.function.arguments, tool_call_id=c.id)
+                part.tool_call_id = _guard_tool_call_id(part)
+                items.append(part)
         return ModelResponse(
             items,
             usage=_map_usage(response),

{pydantic_ai_slim-0.2.12 → pydantic_ai_slim-0.2.14}/pydantic_ai/tools.py

@@ -392,7 +392,7 @@ class Tool(Generic[AgentDepsT]):
             raise UnexpectedModelBehavior(f'Tool exceeded max retries count of {self.max_retries}') from exc
         else:
             if isinstance(exc, ValidationError):
-                content = exc.errors(include_url=False)
+                content = exc.errors(include_url=False, include_context=False)
             else:
                 content = exc.message
             return _messages.RetryPromptPart(