pydantic-ai-slim 0.2.17__tar.gz → 0.2.18__tar.gz

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.2.17
+Version: 0.2.18
 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.17
+Requires-Dist: pydantic-graph==0.2.18
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.2.17; extra == 'a2a'
+Requires-Dist: fasta2a==0.2.18; 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.17; extra == 'evals'
+Requires-Dist: pydantic-evals==0.2.18; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: groq
@@ -56,7 +56,7 @@ Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.9.2; (python_version >= '3.10') and extra == 'mcp'
+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

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/pydantic_ai/_agent_graph.py

@@ -183,6 +183,16 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
 
         if user_prompt is not None:
             parts.append(_messages.UserPromptPart(user_prompt))
+        elif (
+            len(parts) == 0
+            and message_history
+            and (last_message := message_history[-1])
+            and isinstance(last_message, _messages.ModelRequest)
+        ):
+            # Drop last message that came from history and reuse its parts
+            messages.pop()
+            parts.extend(last_message.parts)
+
         return messages, _messages.ModelRequest(parts, instructions=instructions)
 
     async def _reevaluate_dynamic_prompts(

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/pydantic_ai/mcp.py

@@ -5,25 +5,28 @@ import functools
 import json
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Sequence
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
 from types import TracebackType
-from typing import Any
+from typing import Any, Callable
 
 import anyio
 import httpx
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp.client.streamable_http import GetSessionIdCallback, streamablehttp_client
 from mcp.shared.message import SessionMessage
 from mcp.types import (
+    AudioContent,
     BlobResourceContents,
+    Content,
     EmbeddedResource,
     ImageContent,
     LoggingLevel,
     TextContent,
     TextResourceContents,
 )
-from typing_extensions import Self, assert_never
+from typing_extensions import Self, assert_never, deprecated
 
 from pydantic_ai.exceptions import ModelRetry
 from pydantic_ai.messages import BinaryContent
@@ -39,7 +42,7 @@ except ImportError as _import_error:
         'you can use the `mcp` optional group — `pip install "pydantic-ai-slim[mcp]"`'
     ) from _import_error
 
-__all__ = 'MCPServer', 'MCPServerStdio', 'MCPServerHTTP'
+__all__ = 'MCPServer', 'MCPServerStdio', 'MCPServerHTTP', 'MCPServerSSE', 'MCPServerStreamableHTTP'
 
 
 class MCPServer(ABC):
@@ -160,9 +163,7 @@ class MCPServer(ABC):
         await self._exit_stack.aclose()
         self.is_running = False
 
-    def _map_tool_result_part(
-        self, part: TextContent | ImageContent | EmbeddedResource
-    ) -> str | BinaryContent | dict[str, Any] | list[Any]:
+    def _map_tool_result_part(self, part: Content) -> str | BinaryContent | dict[str, Any] | list[Any]:
         # See https://github.com/jlowin/fastmcp/blob/main/docs/servers/tools.mdx#return-values
 
         if isinstance(part, TextContent):
@@ -175,6 +176,10 @@ class MCPServer(ABC):
             return text
         elif isinstance(part, ImageContent):
             return BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)
+        elif isinstance(part, AudioContent):
+            # NOTE: The FastMCP server doesn't support audio content.
+            # See <https://github.com/modelcontextprotocol/python-sdk/issues/952> for more details.
+            return BinaryContent(data=base64.b64decode(part.data), media_type=part.mimeType)  # pragma: no cover
         elif isinstance(part, EmbeddedResource):
             resource = part.resource
             if isinstance(resource, TextResourceContents):
@@ -287,44 +292,12 @@ class MCPServerStdio(MCPServer):
 
 
 @dataclass
-class MCPServerHTTP(MCPServer):
-    """An MCP server that connects over streamable HTTP connections.
-
-    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 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
-        to a server which should already be running.
-
-    Example:
-    ```python {py="3.10"}
-    from pydantic_ai import Agent
-    from pydantic_ai.mcp import MCPServerHTTP
-
-    server = MCPServerHTTP('http://localhost:3001/sse')  # (1)!
-    agent = Agent('openai:gpt-4o', mcp_servers=[server])
-
-    async def main():
-        async with agent.run_mcp_servers():  # (2)!
-            ...
-    ```
-
-    1. E.g. you might be connecting to a server run with [`mcp-run-python`](../mcp/run-python.md).
-    2. This will connect to a server running on `localhost:3001`.
-    """
-
+class _MCPServerHTTP(MCPServer):
     url: str
-    """The URL of the SSE endpoint on the MCP server.
-
-    For example for a server running locally, this might be `http://localhost:3001/sse`.
-    """
+    """The URL of the endpoint on the MCP server."""
 
     headers: dict[str, Any] | None = None
-    """Optional HTTP headers to be sent with each request to the SSE endpoint.
+    """Optional HTTP headers to be sent with each request to the endpoint.
 
     These headers will be passed directly to the underlying `httpx.AsyncClient`.
     Useful for authentication, custom headers, or other HTTP-specific configurations.
@@ -336,22 +309,22 @@ class MCPServerHTTP(MCPServer):
     """
 
     http_client: httpx.AsyncClient | None = None
-    """An `httpx.AsyncClient` to use with the SSE endpoint.
+    """An `httpx.AsyncClient` to use with the endpoint.
 
     This client may be configured to use customized connection parameters like self-signed certificates.
 
     !!! note
         You can either pass `headers` or `http_client`, but not both.
 
-        If you want to use both, you can pass the headers to the `http_client` instead:
+        If you want to use both, you can pass the headers to the `http_client` instead.
 
-        ```python {py="3.10"}
+        ```python {py="3.10" test="skip"}
         import httpx
 
-        from pydantic_ai.mcp import MCPServerHTTP
+        from pydantic_ai.mcp import MCPServerSSE
 
         http_client = httpx.AsyncClient(headers={'Authorization': 'Bearer ...'})
-        server = MCPServerHTTP('http://localhost:3001/sse', http_client=http_client)
+        server = MCPServerSSE('http://localhost:3001/sse', http_client=http_client)
         ```
     """
 
@@ -369,10 +342,11 @@ class MCPServerHTTP(MCPServer):
     If no new messages are received within this time, the connection will be considered stale
     and may be closed. Defaults to 5 minutes (300 seconds).
     """
+
     log_level: LoggingLevel | None = None
     """The log level to set when connecting to the server, if any.
 
-    See <https://modelcontextprotocol.io/specification/2025-03-26/server/utilities/logging#logging> for more details.
+    See <https://modelcontextprotocol.io/introduction#logging> for more details.
 
     If `None`, no log level will be set.
     """
@@ -385,6 +359,27 @@ class MCPServerHTTP(MCPServer):
     For example, if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
     """
 
+    @property
+    @abstractmethod
+    def _transport_client(
+        self,
+    ) -> Callable[
+        ...,
+        AbstractAsyncContextManager[
+            tuple[
+                MemoryObjectReceiveStream[SessionMessage | Exception],
+                MemoryObjectSendStream[SessionMessage],
+                GetSessionIdCallback,
+            ],
+        ]
+        | AbstractAsyncContextManager[
+            tuple[
+                MemoryObjectReceiveStream[SessionMessage | Exception],
+                MemoryObjectSendStream[SessionMessage],
+            ]
+        ],
+    ]: ...
+
     @asynccontextmanager
     async def client_streams(
         self,
@@ -394,8 +389,8 @@ class MCPServerHTTP(MCPServer):
         if self.http_client and self.headers:
             raise ValueError('`http_client` is mutually exclusive with `headers`.')
 
-        sse_client_partial = functools.partial(
-            sse_client,
+        transport_client_partial = functools.partial(
+            self._transport_client,
             url=self.url,
             timeout=self.timeout,
             sse_read_timeout=self.sse_read_timeout,
@@ -411,17 +406,114 @@ class MCPServerHTTP(MCPServer):
                 assert self.http_client is not None
                 return self.http_client
 
-            async with sse_client_partial(httpx_client_factory=httpx_client_factory) as (read_stream, write_stream):
+            async with transport_client_partial(httpx_client_factory=httpx_client_factory) as (
+                read_stream,
+                write_stream,
+                *_,
+            ):
                 yield read_stream, write_stream
         else:
-            async with sse_client_partial(headers=self.headers) as (read_stream, write_stream):
+            async with transport_client_partial(headers=self.headers) as (read_stream, write_stream, *_):
                 yield read_stream, write_stream
 
     def _get_log_level(self) -> LoggingLevel | None:
         return self.log_level
 
     def __repr__(self) -> str:  # pragma: no cover
-        return f'MCPServerHTTP(url={self.url!r}, tool_prefix={self.tool_prefix!r})'
+        return f'{self.__class__.__name__}(url={self.url!r}, tool_prefix={self.tool_prefix!r})'
 
     def _get_client_initialize_timeout(self) -> float:  # pragma: no cover
         return self.timeout
+
+
+@dataclass
+class MCPServerSSE(_MCPServerHTTP):
+    """An MCP server that connects over streamable HTTP connections.
+
+    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.
+
+    !!! note
+        Using this class as an async context manager will create a new pool of HTTP connections to connect
+        to a server which should already be running.
+
+    Example:
+    ```python {py="3.10"}
+    from pydantic_ai import Agent
+    from pydantic_ai.mcp import MCPServerSSE
+
+    server = MCPServerSSE('http://localhost:3001/sse')  # (1)!
+    agent = Agent('openai:gpt-4o', mcp_servers=[server])
+
+    async def main():
+        async with agent.run_mcp_servers():  # (2)!
+            ...
+    ```
+
+    1. E.g. you might be connecting to a server run with [`mcp-run-python`](../mcp/run-python.md).
+    2. This will connect to a server running on `localhost:3001`.
+    """
+
+    @property
+    def _transport_client(self):
+        return sse_client  # pragma: no cover
+
+
+@deprecated('The `MCPServerHTTP` class is deprecated, use `MCPServerSSE` instead.')
+@dataclass
+class MCPServerHTTP(MCPServerSSE):
+    """An MCP server that connects over HTTP using the old SSE transport.
+
+    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.
+
+    !!! note
+        Using this class as an async context manager will create a new pool of HTTP connections to connect
+        to a server which should already be running.
+
+    Example:
+    ```python {py="3.10" test="skip"}
+    from pydantic_ai import Agent
+    from pydantic_ai.mcp import MCPServerHTTP
+
+    server = MCPServerHTTP('http://localhost:3001/sse')  # (1)!
+    agent = Agent('openai:gpt-4o', mcp_servers=[server])
+
+    async def main():
+        async with agent.run_mcp_servers():  # (2)!
+            ...
+    ```
+
+    1. E.g. you might be connecting to a server run with [`mcp-run-python`](../mcp/run-python.md).
+    2. This will connect to a server running on `localhost:3001`.
+    """
+
+
+@dataclass
+class MCPServerStreamableHTTP(_MCPServerHTTP):
+    """An MCP server that connects over HTTP using the Streamable HTTP transport.
+
+    This class implements the Streamable HTTP transport from the MCP specification.
+    See <https://modelcontextprotocol.io/introduction#streamable-http> for more information.
+
+    !!! note
+        Using this class as an async context manager will create a new pool of HTTP connections to connect
+        to a server which should already be running.
+
+    Example:
+    ```python {py="3.10"}
+    from pydantic_ai import Agent
+    from pydantic_ai.mcp import MCPServerStreamableHTTP
+
+    server = MCPServerStreamableHTTP('http://localhost:8000/mcp')  # (1)!
+    agent = Agent('openai:gpt-4o', mcp_servers=[server])
+
+    async def main():
+        async with agent.run_mcp_servers():  # (2)!
+            ...
+    ```
+    """
+
+    @property
+    def _transport_client(self):
+        return streamablehttp_client  # pragma: no cover

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/pydantic_ai/models/__init__.py

@@ -555,9 +555,9 @@ def infer_model(model: Model | KnownModelName | str) -> Model:
 
         return OpenAIModel(model_name, provider=provider)
     elif provider in ('google-gla', 'google-vertex'):
-        from .gemini import GeminiModel
+        from .google import GoogleModel
 
-        return GeminiModel(model_name, provider=provider)
+        return GoogleModel(model_name, provider=provider)
     elif provider == 'groq':
         from .groq import GroqModel
 

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/pydantic_ai/models/anthropic.py

@@ -276,7 +276,7 @@ class AnthropicModel(Model):
             tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
-    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[BetaMessageParam]]:
+    async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[BetaMessageParam]]:  # noqa: C901
         """Just maps a `pydantic_ai.Message` to a `anthropic.types.MessageParam`."""
         system_prompt_parts: list[str] = []
         anthropic_messages: list[BetaMessageParam] = []
@@ -315,7 +315,8 @@ class AnthropicModel(Model):
                 assistant_content_params: list[BetaTextBlockParam | BetaToolUseBlockParam] = []
                 for response_part in m.parts:
                     if isinstance(response_part, TextPart):
-                        assistant_content_params.append(BetaTextBlockParam(text=response_part.content, type='text'))
+                        if response_part.content:  # Only add non-empty text
+                            assistant_content_params.append(BetaTextBlockParam(text=response_part.content, type='text'))
                     else:
                         tool_use_block_param = BetaToolUseBlockParam(
                             id=_guard_tool_call_id(t=response_part),
@@ -324,7 +325,8 @@ class AnthropicModel(Model):
                             input=response_part.args_as_dict(),
                         )
                         assistant_content_params.append(tool_use_block_param)
-                anthropic_messages.append(BetaMessageParam(role='assistant', content=assistant_content_params))
+                if len(assistant_content_params) > 0:
+                    anthropic_messages.append(BetaMessageParam(role='assistant', content=assistant_content_params))
             else:
                 assert_never(m)
         system_prompt = '\n\n'.join(system_prompt_parts)
@@ -337,11 +339,13 @@ class AnthropicModel(Model):
         part: UserPromptPart,
     ) -> AsyncGenerator[BetaContentBlockParam]:
         if isinstance(part.content, str):
-            yield BetaTextBlockParam(text=part.content, type='text')
+            if part.content:  # Only yield non-empty text
+                yield BetaTextBlockParam(text=part.content, type='text')
         else:
             for item in part.content:
                 if isinstance(item, str):
-                    yield BetaTextBlockParam(text=item, type='text')
+                    if item:  # Only yield non-empty text
+                        yield BetaTextBlockParam(text=item, type='text')
                 elif isinstance(item, BinaryContent):
                     if item.is_image:
                         yield BetaImageBlockParam(

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/pydantic_ai/models/openai.py

@@ -613,7 +613,13 @@ class OpenAIResponsesModel(Model):
         for item in response.output:
             if item.type == 'function_call':
                 items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
-        return ModelResponse(items, usage=_map_usage(response), model_name=response.model, timestamp=timestamp)
+        return ModelResponse(
+            items,
+            usage=_map_usage(response),
+            model_name=response.model,
+            vendor_id=response.id,
+            timestamp=timestamp,
+        )
 
     async def _process_streamed_response(
         self, response: AsyncStream[responses.ResponseStreamEvent]

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/pydantic_ai/providers/google.py

@@ -84,7 +84,7 @@ class GoogleProvider(Provider[genai.Client]):
         """
         if client is None:
             # NOTE: We are keeping GEMINI_API_KEY for backwards compatibility.
-            api_key = api_key or os.environ.get('GOOGLE_API_KEY')
+            api_key = api_key or os.getenv('GOOGLE_API_KEY') or os.getenv('GEMINI_API_KEY')
 
             if vertexai is None:  # pragma: lax no cover
                 vertexai = bool(location or project or credentials)

{pydantic_ai_slim-0.2.17 → pydantic_ai_slim-0.2.18}/pyproject.toml

@@ -75,7 +75,7 @@ tavily = ["tavily-python>=0.5.0"]
 # CLI
 cli = ["rich>=13", "prompt-toolkit>=3", "argcomplete>=3.5.0"]
 # MCP
-mcp = ["mcp>=1.9.2; python_version >= '3.10'"]
+mcp = ["mcp>=1.9.4; python_version >= '3.10'"]
 # Evals
 evals = ["pydantic-evals=={{ version }}"]
 # A2A