pydantic-ai-slim 0.2.5__tar.gz → 0.2.7__tar.gz

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.2.5
+Version: 0.2.7
 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.5
+Requires-Dist: pydantic-graph==0.2.7
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.2.5; extra == 'a2a'
+Requires-Dist: fasta2a==0.2.7; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.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.5; extra == 'evals'
+Requires-Dist: pydantic-evals==0.2.7; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/_agent_graph.py

@@ -26,7 +26,7 @@ from . import (
 )
 from .result import OutputDataT, ToolOutput
 from .settings import ModelSettings, merge_model_settings
-from .tools import RunContext, Tool, ToolDefinition
+from .tools import RunContext, Tool, ToolDefinition, ToolsPrepareFunc
 
 if TYPE_CHECKING:
     from .mcp import MCPServer
@@ -97,6 +97,8 @@ class GraphAgentDeps(Generic[DepsT, OutputDataT]):
 
     tracer: Tracer
 
+    prepare_tools: ToolsPrepareFunc[DepsT] | None = None
+
 
 class AgentNode(BaseNode[GraphAgentState, GraphAgentDeps[DepsT, Any], result.FinalResult[NodeRunEndT]]):
     """The base class for all agent nodes.
@@ -220,26 +222,44 @@ async def _prepare_request_parameters(
     ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]],
 ) -> models.ModelRequestParameters:
     """Build tools and create an agent model."""
-    function_tool_defs: list[ToolDefinition] = []
+    function_tool_defs_map: dict[str, ToolDefinition] = {}
 
     run_context = build_run_context(ctx)
 
     async def add_tool(tool: Tool[DepsT]) -> None:
         ctx = run_context.replace_with(retry=tool.current_retry, tool_name=tool.name)
         if tool_def := await tool.prepare_tool_def(ctx):
-            function_tool_defs.append(tool_def)
+            # prepare_tool_def may change tool_def.name
+            if tool_def.name in function_tool_defs_map:
+                if tool_def.name != tool.name:
+                    # Prepare tool def may have renamed the tool
+                    raise exceptions.UserError(
+                        f"Renaming tool '{tool.name}' to '{tool_def.name}' conflicts with existing tool."
+                    )
+                else:
+                    raise exceptions.UserError(f'Tool name conflicts with existing tool: {tool.name!r}.')
+            function_tool_defs_map[tool_def.name] = tool_def
 
     async def add_mcp_server_tools(server: MCPServer) -> None:
         if not server.is_running:
             raise exceptions.UserError(f'MCP server is not running: {server}')
         tool_defs = await server.list_tools()
-        # TODO(Marcelo): We should check if the tool names are unique. If not, we should raise an error.
-        function_tool_defs.extend(tool_defs)
+        for tool_def in tool_defs:
+            if tool_def.name in function_tool_defs_map:
+                raise exceptions.UserError(
+                    f"MCP Server '{server}' defines a tool whose name conflicts with existing tool: {tool_def.name!r}. Consider using `tool_prefix` to avoid name conflicts."
+                )
+            function_tool_defs_map[tool_def.name] = tool_def
 
     await asyncio.gather(
         *map(add_tool, ctx.deps.function_tools.values()),
         *map(add_mcp_server_tools, ctx.deps.mcp_servers),
     )
+    function_tool_defs = list(function_tool_defs_map.values())
+    if ctx.deps.prepare_tools:
+        # Prepare the tools using the provided function
+        # This also acts over tool definitions pulled from MCP servers
+        function_tool_defs = await ctx.deps.prepare_tools(run_context, function_tool_defs) or []
 
     output_schema = ctx.deps.output_schema
     return models.ModelRequestParameters(

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/_cli.py

@@ -53,7 +53,7 @@ PYDANTIC_AI_HOME = Path.home() / '.pydantic-ai'
 This folder is used to store the prompt history and configuration.
 """
 
-PROMPT_HISTORY_PATH = PYDANTIC_AI_HOME / 'prompt-history.txt'
+PROMPT_HISTORY_FILENAME = 'prompt-history.txt'
 
 
 class SimpleCodeBlock(CodeBlock):
@@ -211,27 +211,26 @@ Special prompts:
             pass
         return 0
 
-    # Ensure the history directory and file exist
-    PROMPT_HISTORY_PATH.parent.mkdir(parents=True, exist_ok=True)
-    PROMPT_HISTORY_PATH.touch(exist_ok=True)
-
-    # doing this instead of `PromptSession[Any](history=` allows mocking of PromptSession in tests
-    session: PromptSession[Any] = PromptSession(history=FileHistory(str(PROMPT_HISTORY_PATH)))
     try:
-        return asyncio.run(run_chat(session, stream, agent, console, code_theme, prog_name))
+        return asyncio.run(run_chat(stream, agent, console, code_theme, prog_name))
     except KeyboardInterrupt:  # pragma: no cover
         return 0
 
 
 async def run_chat(
-    session: PromptSession[Any],
     stream: bool,
     agent: Agent[AgentDepsT, OutputDataT],
     console: Console,
     code_theme: str,
     prog_name: str,
+    config_dir: Path | None = None,
     deps: AgentDepsT = None,
 ) -> int:
+    prompt_history_path = (config_dir or PYDANTIC_AI_HOME) / PROMPT_HISTORY_FILENAME
+    prompt_history_path.parent.mkdir(parents=True, exist_ok=True)
+    prompt_history_path.touch(exist_ok=True)
+    session: PromptSession[Any] = PromptSession(history=FileHistory(str(prompt_history_path)))
+
     multiline = False
     messages: list[ModelMessage] = []
 

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/_output.py

@@ -231,9 +231,13 @@ class OutputSchemaTool(Generic[OutputDataT]):
         try:
             pyd_allow_partial: Literal['off', 'trailing-strings'] = 'trailing-strings' if allow_partial else 'off'
             if isinstance(tool_call.args, str):
-                output = self.type_adapter.validate_json(tool_call.args, experimental_allow_partial=pyd_allow_partial)
+                output = self.type_adapter.validate_json(
+                    tool_call.args or '{}', experimental_allow_partial=pyd_allow_partial
+                )
             else:
-                output = self.type_adapter.validate_python(tool_call.args, experimental_allow_partial=pyd_allow_partial)
+                output = self.type_adapter.validate_python(
+                    tool_call.args or {}, experimental_allow_partial=pyd_allow_partial
+                )
         except ValidationError as e:
             if wrap_validation_errors:
                 m = _messages.RetryPromptPart(

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/_parts_manager.py

@@ -132,7 +132,7 @@ class ModelResponsePartsManager:
     ) -> ModelResponseStreamEvent | None:
         """Handle or update a tool call, creating or updating a `ToolCallPart` or `ToolCallPartDelta`.
 
-        Managed items remain as `ToolCallPartDelta`s until they have both a tool_name and arguments, at which
+        Managed items remain as `ToolCallPartDelta`s until they have at least a tool_name, at which
         point they are upgraded to `ToolCallPart`s.
 
         If `vendor_part_id` is None, updates the latest matching ToolCallPart (or ToolCallPartDelta)
@@ -143,11 +143,11 @@ class ModelResponsePartsManager:
                 If None, the latest matching tool call may be updated.
             tool_name: The name of the tool. If None, the manager does not enforce
                 a name match when `vendor_part_id` is None.
-            args: Arguments for the tool call, either as a string or a dictionary of key-value pairs.
+            args: Arguments for the tool call, either as a string, a dictionary of key-value pairs, or None.
             tool_call_id: An optional string representing an identifier for this tool call.
 
         Returns:
-            - A `PartStartEvent` if a new (fully realized) ToolCallPart is created.
+            - A `PartStartEvent` if a new ToolCallPart is created.
             - A `PartDeltaEvent` if an existing part is updated.
             - `None` if no new event is emitted (e.g., the part is still incomplete).
 
@@ -207,7 +207,7 @@ class ModelResponsePartsManager:
         *,
         vendor_part_id: Hashable | None,
         tool_name: str,
-        args: str | dict[str, Any],
+        args: str | dict[str, Any] | None,
         tool_call_id: str | None = None,
     ) -> ModelResponseStreamEvent:
         """Immediately create or fully-overwrite a ToolCallPart with the given information.
@@ -218,7 +218,7 @@ class ModelResponsePartsManager:
             vendor_part_id: The vendor's ID for this tool call part. If not
                 None and an existing part is found, that part is overwritten.
             tool_name: The name of the tool being invoked.
-            args: The arguments for the tool call, either as a string or a dictionary.
+            args: The arguments for the tool call, either as a string, a dictionary, or None.
             tool_call_id: An optional string identifier for this tool call.
 
         Returns:

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/_pydantic.py

@@ -76,8 +76,15 @@ def function_schema(  # noqa: C901
     description, field_descriptions = doc_descriptions(function, sig, docstring_format=docstring_format)
 
     if require_parameter_descriptions:
-        if len(field_descriptions) != len(sig.parameters):
+        if takes_ctx:
+            parameters_without_ctx = set(
+                name for name in sig.parameters if not _is_call_ctx(sig.parameters[name].annotation)
+            )
+            missing_params = parameters_without_ctx - set(field_descriptions)
+        else:
             missing_params = set(sig.parameters) - set(field_descriptions)
+
+        if missing_params:
             errors.append(f'Missing parameter descriptions for {", ".join(missing_params)}')
 
     for index, (name, p) in enumerate(sig.parameters.items()):

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/_utils.py

@@ -5,7 +5,7 @@ import time
 import uuid
 from collections.abc import AsyncIterable, AsyncIterator, Iterator
 from contextlib import asynccontextmanager, suppress
-from dataclasses import dataclass, is_dataclass
+from dataclasses import dataclass, fields, is_dataclass
 from datetime import datetime, timezone
 from functools import partial
 from types import GenericAlias
@@ -290,3 +290,11 @@ class PeekableAsyncStream(Generic[T]):
 
 def get_traceparent(x: AgentRun | AgentRunResult | GraphRun | GraphRunResult) -> str:
     return x._traceparent(required=False) or ''  # type: ignore[reportPrivateUsage]
+
+
+def dataclasses_no_defaults_repr(self: Any) -> str:
+    """Exclude fields with values equal to the field default."""
+    kv_pairs = (
+        f'{f.name}={getattr(self, f.name)!r}' for f in fields(self) if f.repr and getattr(self, f.name) != f.default
+    )
+    return f'{self.__class__.__qualname__}({", ".join(kv_pairs)})'

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/agent.py

@@ -42,6 +42,7 @@ from .tools import (
     ToolFuncPlain,
     ToolParams,
     ToolPrepareFunc,
+    ToolsPrepareFunc,
 )
 
 # Re-exporting like this improves auto-import behavior in PyCharm
@@ -148,6 +149,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
     _system_prompt_dynamic_functions: dict[str, _system_prompt.SystemPromptRunner[AgentDepsT]] = dataclasses.field(
         repr=False
     )
+    _prepare_tools: ToolsPrepareFunc[AgentDepsT] | None = dataclasses.field(repr=False)
     _function_tools: dict[str, Tool[AgentDepsT]] = dataclasses.field(repr=False)
     _mcp_servers: Sequence[MCPServer] = dataclasses.field(repr=False)
     _default_retries: int = dataclasses.field(repr=False)
@@ -172,6 +174,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         retries: int = 1,
         output_retries: int | None = None,
         tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = (),
+        prepare_tools: ToolsPrepareFunc[AgentDepsT] | None = None,
         mcp_servers: Sequence[MCPServer] = (),
         defer_model_check: bool = False,
         end_strategy: EndStrategy = 'early',
@@ -200,6 +203,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         result_tool_description: str | None = None,
         result_retries: int | None = None,
         tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = (),
+        prepare_tools: ToolsPrepareFunc[AgentDepsT] | None = None,
         mcp_servers: Sequence[MCPServer] = (),
         defer_model_check: bool = False,
         end_strategy: EndStrategy = 'early',
@@ -223,6 +227,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         retries: int = 1,
         output_retries: int | None = None,
         tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = (),
+        prepare_tools: ToolsPrepareFunc[AgentDepsT] | None = None,
         mcp_servers: Sequence[MCPServer] = (),
         defer_model_check: bool = False,
         end_strategy: EndStrategy = 'early',
@@ -251,6 +256,9 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             output_retries: The maximum number of retries to allow for result validation, defaults to `retries`.
             tools: Tools to register with the agent, you can also register tools via the decorators
                 [`@agent.tool`][pydantic_ai.Agent.tool] and [`@agent.tool_plain`][pydantic_ai.Agent.tool_plain].
+            prepare_tools: custom method to prepare the tool definition of all tools for each step.
+                This is useful if you want to customize the definition of multiple tools or you want to register
+                a subset of tools for a given step. See [`ToolsPrepareFunc`][pydantic_ai.tools.ToolsPrepareFunc]
             mcp_servers: MCP servers to register with the agent. You should register a [`MCPServer`][pydantic_ai.mcp.MCPServer]
                 for each server you want the agent to connect to.
             defer_model_check: by default, if you provide a [named][pydantic_ai.models.KnownModelName] model,
@@ -334,6 +342,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
         self._default_retries = retries
         self._max_result_retries = output_retries if output_retries is not None else retries
         self._mcp_servers = mcp_servers
+        self._prepare_tools = prepare_tools
         for tool in tools:
             if isinstance(tool, Tool):
                 self._register_tool(tool)
@@ -565,30 +574,21 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
                             UserPromptPart(
                                 content='What is the capital of France?',
                                 timestamp=datetime.datetime(...),
-                                part_kind='user-prompt',
                             )
-                        ],
-                        instructions=None,
-                        kind='request',
+                        ]
                     )
                 ),
                 CallToolsNode(
                     model_response=ModelResponse(
-                        parts=[TextPart(content='Paris', part_kind='text')],
+                        parts=[TextPart(content='Paris')],
                         usage=Usage(
-                            requests=1,
-                            request_tokens=56,
-                            response_tokens=1,
-                            total_tokens=57,
-                            details=None,
+                            requests=1, request_tokens=56, response_tokens=1, total_tokens=57
                         ),
                         model_name='gpt-4o',
                         timestamp=datetime.datetime(...),
-                        kind='response',
-                        vendor_id=None,
                     )
                 ),
-                End(data=FinalResult(output='Paris', tool_name=None, tool_call_id=None)),
+                End(data=FinalResult(output='Paris')),
             ]
             '''
             print(agent_run.result.output)
@@ -694,6 +694,7 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             mcp_servers=self._mcp_servers,
             default_retries=self._default_retries,
             tracer=tracer,
+            prepare_tools=self._prepare_tools,
             get_instructions=get_instructions,
         )
         start_node = _agent_graph.UserPromptNode[AgentDepsT](
@@ -1750,9 +1751,13 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             lifespan=lifespan,
         )
 
-    async def to_cli(self: Self, deps: AgentDepsT = None) -> None:
+    async def to_cli(self: Self, deps: AgentDepsT = None, prog_name: str = 'pydantic-ai') -> None:
         """Run the agent in a CLI chat interface.
 
+        Args:
+            deps: The dependencies to pass to the agent.
+            prog_name: The name of the program to use for the CLI. Defaults to 'pydantic-ai'.
+
         Example:
         ```python {title="agent_to_cli.py" test="skip"}
         from pydantic_ai import Agent
@@ -1763,37 +1768,28 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             await agent.to_cli()
         ```
         """
-        from prompt_toolkit import PromptSession
-        from prompt_toolkit.history import FileHistory
         from rich.console import Console
 
-        from pydantic_ai._cli import PROMPT_HISTORY_PATH, run_chat
+        from pydantic_ai._cli import run_chat
 
-        # TODO(Marcelo): We need to refactor the CLI code to be able to be able to just pass `agent`, `deps` and
-        # `prog_name` from here.
+        await run_chat(stream=True, agent=self, deps=deps, console=Console(), code_theme='monokai', prog_name=prog_name)
 
-        session: PromptSession[Any] = PromptSession(history=FileHistory(str(PROMPT_HISTORY_PATH)))
-        await run_chat(
-            session=session,
-            stream=True,
-            agent=self,
-            deps=deps,
-            console=Console(),
-            code_theme='monokai',
-            prog_name='pydantic-ai',
-        )
-
-    def to_cli_sync(self: Self, deps: AgentDepsT = None) -> None:
+    def to_cli_sync(self: Self, deps: AgentDepsT = None, prog_name: str = 'pydantic-ai') -> None:
         """Run the agent in a CLI chat interface with the non-async interface.
 
+        Args:
+            deps: The dependencies to pass to the agent.
+            prog_name: The name of the program to use for the CLI. Defaults to 'pydantic-ai'.
+
         ```python {title="agent_to_cli_sync.py" test="skip"}
         from pydantic_ai import Agent
 
         agent = Agent('openai:gpt-4o', instructions='You always respond in Italian.')
         agent.to_cli_sync()
+        agent.to_cli_sync(prog_name='assistant')
         ```
         """
-        return get_event_loop().run_until_complete(self.to_cli(deps=deps))
+        return get_event_loop().run_until_complete(self.to_cli(deps=deps, prog_name=prog_name))
 
 
 @dataclasses.dataclass(repr=False)
@@ -1835,30 +1831,21 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
                         UserPromptPart(
                             content='What is the capital of France?',
                             timestamp=datetime.datetime(...),
-                            part_kind='user-prompt',
                         )
-                    ],
-                    instructions=None,
-                    kind='request',
+                    ]
                 )
             ),
             CallToolsNode(
                 model_response=ModelResponse(
-                    parts=[TextPart(content='Paris', part_kind='text')],
+                    parts=[TextPart(content='Paris')],
                     usage=Usage(
-                        requests=1,
-                        request_tokens=56,
-                        response_tokens=1,
-                        total_tokens=57,
-                        details=None,
+                        requests=1, request_tokens=56, response_tokens=1, total_tokens=57
                     ),
                     model_name='gpt-4o',
                     timestamp=datetime.datetime(...),
-                    kind='response',
-                    vendor_id=None,
                 )
             ),
-            End(data=FinalResult(output='Paris', tool_name=None, tool_call_id=None)),
+            End(data=FinalResult(output='Paris')),
         ]
         '''
         print(agent_run.result.output)
@@ -1981,30 +1968,24 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
                                 UserPromptPart(
                                     content='What is the capital of France?',
                                     timestamp=datetime.datetime(...),
-                                    part_kind='user-prompt',
                                 )
-                            ],
-                            instructions=None,
-                            kind='request',
+                            ]
                         )
                     ),
                     CallToolsNode(
                         model_response=ModelResponse(
-                            parts=[TextPart(content='Paris', part_kind='text')],
+                            parts=[TextPart(content='Paris')],
                             usage=Usage(
                                 requests=1,
                                 request_tokens=56,
                                 response_tokens=1,
                                 total_tokens=57,
-                                details=None,
                             ),
                             model_name='gpt-4o',
                             timestamp=datetime.datetime(...),
-                            kind='response',
-                            vendor_id=None,
                         )
                     ),
-                    End(data=FinalResult(output='Paris', tool_name=None, tool_call_id=None)),
+                    End(data=FinalResult(output='Paris')),
                 ]
                 '''
                 print('Final result:', agent_run.result.output)

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/direct.py

@@ -41,18 +41,10 @@ async def model_request(
         print(model_response)
         '''
         ModelResponse(
-            parts=[TextPart(content='Paris', part_kind='text')],
-            usage=Usage(
-                requests=1,
-                request_tokens=56,
-                response_tokens=1,
-                total_tokens=57,
-                details=None,
-            ),
+            parts=[TextPart(content='Paris')],
+            usage=Usage(requests=1, request_tokens=56, response_tokens=1, total_tokens=57),
             model_name='claude-3-5-haiku-latest',
             timestamp=datetime.datetime(...),
-            kind='response',
-            vendor_id=None,
         )
         '''
     ```
@@ -102,14 +94,10 @@ def model_request_sync(
     print(model_response)
     '''
     ModelResponse(
-        parts=[TextPart(content='Paris', part_kind='text')],
-        usage=Usage(
-            requests=1, request_tokens=56, response_tokens=1, total_tokens=57, details=None
-        ),
+        parts=[TextPart(content='Paris')],
+        usage=Usage(requests=1, request_tokens=56, response_tokens=1, total_tokens=57),
         model_name='claude-3-5-haiku-latest',
         timestamp=datetime.datetime(...),
-        kind='response',
-        vendor_id=None,
     )
     '''
     ```
@@ -163,23 +151,11 @@ def model_request_stream(
             print(chunks)
             '''
             [
-                PartStartEvent(
-                    index=0,
-                    part=TextPart(content='Albert Einstein was ', part_kind='text'),
-                    event_kind='part_start',
-                ),
-                PartDeltaEvent(
-                    index=0,
-                    delta=TextPartDelta(
-                        content_delta='a German-born theoretical ', part_delta_kind='text'
-                    ),
-                    event_kind='part_delta',
-                ),
+                PartStartEvent(index=0, part=TextPart(content='Albert Einstein was ')),
                 PartDeltaEvent(
-                    index=0,
-                    delta=TextPartDelta(content_delta='physicist.', part_delta_kind='text'),
-                    event_kind='part_delta',
+                    index=0, delta=TextPartDelta(content_delta='a German-born theoretical ')
                 ),
+                PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='physicist.')),
             ]
             '''
     ```

{pydantic_ai_slim-0.2.5 → pydantic_ai_slim-0.2.7}/pydantic_ai/mcp.py

@@ -46,6 +46,13 @@ class MCPServer(ABC):
     """
 
     is_running: bool = False
+    tool_prefix: str | None = None
+    """A prefix to add to all tools that are registered with the server.
+
+    If not empty, will include a trailing underscore(`_`).
+
+    e.g. if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
+    """
 
     _client: ClientSession
     _read_stream: MemoryObjectReceiveStream[JSONRPCMessage | Exception]
@@ -57,7 +64,10 @@ class MCPServer(ABC):
     async def client_streams(
         self,
     ) -> AsyncIterator[
-        tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]
+        tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
     ]:
         """Create the streams for the MCP server."""
         raise NotImplementedError('MCP Server subclasses must implement this method.')
@@ -68,6 +78,14 @@ class MCPServer(ABC):
         """Get the log level for the MCP server."""
         raise NotImplementedError('MCP Server subclasses must implement this method.')
 
+    def get_prefixed_tool_name(self, tool_name: str) -> str:
+        """Get the tool name with prefix if `tool_prefix` is set."""
+        return f'{self.tool_prefix}_{tool_name}' if self.tool_prefix else tool_name
+
+    def get_unprefixed_tool_name(self, tool_name: str) -> str:
+        """Get original tool name without prefix for calling tools."""
+        return tool_name.removeprefix(f'{self.tool_prefix}_') if self.tool_prefix else tool_name
+
     async def list_tools(self) -> list[ToolDefinition]:
         """Retrieve tools that are currently active on the server.
 
@@ -78,7 +96,7 @@ class MCPServer(ABC):
         tools = await self._client.list_tools()
         return [
             ToolDefinition(
-                name=tool.name,
+                name=self.get_prefixed_tool_name(tool.name),
                 description=tool.description or '',
                 parameters_json_schema=tool.inputSchema,
             )
@@ -100,7 +118,7 @@ class MCPServer(ABC):
         Raises:
             ModelRetry: If the tool call fails.
         """
-        result = await self._client.call_tool(tool_name, arguments)
+        result = await self._client.call_tool(self.get_unprefixed_tool_name(tool_name), arguments)
 
         content = [self._map_tool_result_part(part) for part in result.content]
 
@@ -126,7 +144,10 @@ class MCPServer(ABC):
         return self
 
     async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ) -> bool | None:
         await self._exit_stack.aclose()
         self.is_running = False
@@ -223,11 +244,22 @@ class MCPServerStdio(MCPServer):
     cwd: str | Path | None = None
     """The working directory to use when spawning the process."""
 
+    tool_prefix: str | None = None
+    """A prefix to add to all tools that are registered with the server.
+
+    If not empty, will include a trailing underscore(`_`).
+
+    e.g. if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
+    """
+
     @asynccontextmanager
     async def client_streams(
         self,
     ) -> AsyncIterator[
-        tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]
+        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):
@@ -236,6 +268,9 @@ class MCPServerStdio(MCPServer):
     def _get_log_level(self) -> LoggingLevel | None:
         return self.log_level
 
+    def __repr__(self) -> str:
+        return f'MCPServerStdio(command={self.command!r}, args={self.args!r}, tool_prefix={self.tool_prefix!r})'
+
 
 @dataclass
 class MCPServerHTTP(MCPServer):
@@ -303,16 +338,33 @@ class MCPServerHTTP(MCPServer):
     If `None`, no log level will be set.
     """
 
+    tool_prefix: str | None = None
+    """A prefix to add to all tools that are registered with the server.
+
+    If not empty, will include a trailing underscore (`_`).
+
+    For example, if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
+    """
+
     @asynccontextmanager
     async def client_streams(
         self,
     ) -> AsyncIterator[
-        tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]
+        tuple[
+            MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+            MemoryObjectSendStream[JSONRPCMessage],
+        ]
     ]:  # pragma: no cover
         async with sse_client(
-            url=self.url, headers=self.headers, timeout=self.timeout, sse_read_timeout=self.sse_read_timeout
+            url=self.url,
+            headers=self.headers,
+            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:
         return self.log_level
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f'MCPServerHTTP(url={self.url!r}, tool_prefix={self.tool_prefix!r})'