pydantic-ai-slim 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

pydantic_ai/agent/__init__.py

@@ -45,15 +45,11 @@ from ..run import AgentRun, AgentRunResult
 from ..settings import ModelSettings, merge_model_settings
 from ..tools import (
     AgentDepsT,
-    DeferredToolCallResult,
-    DeferredToolResult,
     DeferredToolResults,
     DocstringFormat,
     GenerateToolJsonSchema,
     RunContext,
     Tool,
-    ToolApproved,
-    ToolDenied,
     ToolFuncContext,
     ToolFuncEither,
     ToolFuncPlain,
@@ -462,7 +458,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
     ) -> AbstractAsyncContextManager[AgentRun[AgentDepsT, RunOutputDataT]]: ...
 
     @asynccontextmanager
-    async def iter(  # noqa: C901
+    async def iter(
         self,
         user_prompt: str | Sequence[_messages.UserContent] | None = None,
         *,
@@ -505,7 +501,6 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             [
                 UserPromptNode(
                     user_prompt='What is the capital of France?',
-                    instructions=None,
                     instructions_functions=[],
                     system_prompts=(),
                     system_prompt_functions=[],
@@ -559,7 +554,6 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
         del model
 
         deps = self._get_deps(deps)
-        new_message_index = len(message_history) if message_history else 0
         output_schema = self._prepare_output_schema(output_type, model_used.profile)
 
         output_type_ = output_type or self.output_type
@@ -620,27 +614,12 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             instrumentation_settings = None
             tracer = NoOpTracer()
 
-        tool_call_results: dict[str, DeferredToolResult] | None = None
-        if deferred_tool_results is not None:
-            tool_call_results = {}
-            for tool_call_id, approval in deferred_tool_results.approvals.items():
-                if approval is True:
-                    approval = ToolApproved()
-                elif approval is False:
-                    approval = ToolDenied()
-                tool_call_results[tool_call_id] = approval
-
-            if calls := deferred_tool_results.calls:
-                call_result_types = _utils.get_union_args(DeferredToolCallResult)
-                for tool_call_id, result in calls.items():
-                    if not isinstance(result, call_result_types):
-                        result = _messages.ToolReturn(result)
-                    tool_call_results[tool_call_id] = result
-
-        graph_deps = _agent_graph.GraphAgentDeps[AgentDepsT, RunOutputDataT](
+        graph_deps = _agent_graph.GraphAgentDeps[
+            AgentDepsT, RunOutputDataT
+        ](
             user_deps=deps,
             prompt=user_prompt,
-            new_message_index=new_message_index,
+            new_message_index=0,  # This will be set in `UserPromptNode` based on the length of the cleaned message history
             model=model_used,
             model_settings=model_settings,
             usage_limits=usage_limits,
@@ -651,13 +630,13 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             history_processors=self.history_processors,
             builtin_tools=list(self._builtin_tools),
             tool_manager=tool_manager,
-            tool_call_results=tool_call_results,
             tracer=tracer,
             get_instructions=get_instructions,
             instrumentation_settings=instrumentation_settings,
         )
         start_node = _agent_graph.UserPromptNode[AgentDepsT](
             user_prompt=user_prompt,
+            deferred_tool_results=deferred_tool_results,
             instructions=self._instructions,
             instructions_functions=self._instructions_functions,
             system_prompts=self._system_prompts,
@@ -1005,7 +984,9 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
         strict: bool | None = None,
+        sequential: bool = False,
         requires_approval: bool = False,
+        metadata: dict[str, Any] | None = None,
     ) -> Callable[[ToolFuncContext[AgentDepsT, ToolParams]], ToolFuncContext[AgentDepsT, ToolParams]]: ...
 
     def tool(
@@ -1020,7 +1001,9 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
         strict: bool | None = None,
+        sequential: bool = False,
         requires_approval: bool = False,
+        metadata: dict[str, Any] | None = None,
     ) -> Any:
         """Decorator to register a tool function which takes [`RunContext`][pydantic_ai.tools.RunContext] as its first argument.
 
@@ -1065,8 +1048,10 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             schema_generator: The JSON schema generator class to use for this tool. Defaults to `GenerateToolJsonSchema`.
             strict: Whether to enforce JSON schema compliance (only affects OpenAI).
                 See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+            sequential: Whether the function requires a sequential/serial execution environment. Defaults to False.
             requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
                 See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
+            metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization.
         """
 
         def tool_decorator(
@@ -1075,15 +1060,17 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             # noinspection PyTypeChecker
             self._function_toolset.add_function(
                 func_,
-                True,
-                name,
-                retries,
-                prepare,
-                docstring_format,
-                require_parameter_descriptions,
-                schema_generator,
-                strict,
-                requires_approval,
+                takes_ctx=True,
+                name=name,
+                retries=retries,
+                prepare=prepare,
+                docstring_format=docstring_format,
+                require_parameter_descriptions=require_parameter_descriptions,
+                schema_generator=schema_generator,
+                strict=strict,
+                sequential=sequential,
+                requires_approval=requires_approval,
+                metadata=metadata,
             )
             return func_
 
@@ -1104,7 +1091,9 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
         strict: bool | None = None,
+        sequential: bool = False,
         requires_approval: bool = False,
+        metadata: dict[str, Any] | None = None,
     ) -> Callable[[ToolFuncPlain[ToolParams]], ToolFuncPlain[ToolParams]]: ...
 
     def tool_plain(
@@ -1121,6 +1110,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
         strict: bool | None = None,
         sequential: bool = False,
         requires_approval: bool = False,
+        metadata: dict[str, Any] | None = None,
     ) -> Any:
         """Decorator to register a tool function which DOES NOT take `RunContext` as an argument.
 
@@ -1168,22 +1158,24 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             sequential: Whether the function requires a sequential/serial execution environment. Defaults to False.
             requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
                 See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
+            metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization.
         """
 
         def tool_decorator(func_: ToolFuncPlain[ToolParams]) -> ToolFuncPlain[ToolParams]:
             # noinspection PyTypeChecker
             self._function_toolset.add_function(
                 func_,
-                False,
-                name,
-                retries,
-                prepare,
-                docstring_format,
-                require_parameter_descriptions,
-                schema_generator,
-                strict,
-                sequential,
-                requires_approval,
+                takes_ctx=False,
+                name=name,
+                retries=retries,
+                prepare=prepare,
+                docstring_format=docstring_format,
+                require_parameter_descriptions=require_parameter_descriptions,
+                schema_generator=schema_generator,
+                strict=strict,
+                sequential=sequential,
+                requires_approval=requires_approval,
+                metadata=metadata,
             )
             return func_
 

pydantic_ai/agent/abstract.py

@@ -499,12 +499,13 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
                                 ]
 
                                 parts: list[_messages.ModelRequestPart] = []
-                                async for _event in _agent_graph.process_function_tools(
-                                    graph_ctx.deps.tool_manager,
-                                    tool_calls,
-                                    final_result,
-                                    graph_ctx,
-                                    parts,
+                                async for _event in _agent_graph.process_tool_calls(
+                                    tool_manager=graph_ctx.deps.tool_manager,
+                                    tool_calls=tool_calls,
+                                    tool_call_results=None,
+                                    final_result=final_result,
+                                    ctx=graph_ctx,
+                                    output_parts=parts,
                                 ):
                                     pass
                                 if parts:
@@ -621,7 +622,6 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
             [
                 UserPromptNode(
                     user_prompt='What is the capital of France?',
-                    instructions=None,
                     instructions_functions=[],
                     system_prompts=(),
                     system_prompt_functions=[],

pydantic_ai/agent/wrapper.py

@@ -144,7 +144,6 @@ class WrapperAgent(AbstractAgent[AgentDepsT, OutputDataT]):
             [
                 UserPromptNode(
                     user_prompt='What is the capital of France?',
-                    instructions=None,
                     instructions_functions=[],
                     system_prompts=(),
                     system_prompt_functions=[],

pydantic_ai/durable_exec/dbos/_agent.py

@@ -15,7 +15,6 @@ from pydantic_ai import (
 )
 from pydantic_ai.agent import AbstractAgent, AgentRun, AgentRunResult, EventStreamHandler, RunOutputDataT, WrapperAgent
 from pydantic_ai.exceptions import UserError
-from pydantic_ai.mcp import MCPServer
 from pydantic_ai.models import Model
 from pydantic_ai.output import OutputDataT, OutputSpec
 from pydantic_ai.result import StreamedRunResult
@@ -29,7 +28,6 @@ from pydantic_ai.tools import (
 )
 from pydantic_ai.toolsets import AbstractToolset
 
-from ._mcp_server import DBOSMCPServer
 from ._model import DBOSModel
 from ._utils import StepConfig
 
@@ -86,14 +84,21 @@ class DBOSAgent(WrapperAgent[AgentDepsT, OutputDataT], DBOSConfiguredInstance):
 
         def dbosify_toolset(toolset: AbstractToolset[AgentDepsT]) -> AbstractToolset[AgentDepsT]:
             # Replace MCPServer with DBOSMCPServer
-            if isinstance(toolset, MCPServer):
-                return DBOSMCPServer(
-                    wrapped=toolset,
-                    step_name_prefix=dbosagent_name,
-                    step_config=self._mcp_step_config,
-                )
+            try:
+                from pydantic_ai.mcp import MCPServer
+
+                from ._mcp_server import DBOSMCPServer
+            except ImportError:
+                pass
             else:
-                return toolset
+                if isinstance(toolset, MCPServer):
+                    return DBOSMCPServer(
+                        wrapped=toolset,
+                        step_name_prefix=dbosagent_name,
+                        step_config=self._mcp_step_config,
+                    )
+
+            return toolset
 
         dbos_toolsets = [toolset.visit_and_replace(dbosify_toolset) for toolset in wrapped.toolsets]
         self._toolsets = dbos_toolsets
@@ -622,7 +627,6 @@ class DBOSAgent(WrapperAgent[AgentDepsT, OutputDataT], DBOSConfiguredInstance):
             [
                 UserPromptNode(
                     user_prompt='What is the capital of France?',
-                    instructions=None,
                     instructions_functions=[],
                     system_prompts=(),
                     system_prompt_functions=[],

pydantic_ai/durable_exec/dbos/_mcp_server.py

@@ -2,18 +2,20 @@ from __future__ import annotations
 
 from abc import ABC
 from collections.abc import Callable
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from dbos import DBOS
 from typing_extensions import Self
 
-from pydantic_ai.mcp import MCPServer, ToolResult
 from pydantic_ai.tools import AgentDepsT, RunContext
 from pydantic_ai.toolsets.abstract import AbstractToolset, ToolsetTool
 from pydantic_ai.toolsets.wrapper import WrapperToolset
 
 from ._utils import StepConfig
 
+if TYPE_CHECKING:
+    from pydantic_ai.mcp import MCPServer, ToolResult
+
 
 class DBOSMCPServer(WrapperToolset[AgentDepsT], ABC):
     """A wrapper for MCPServer that integrates with DBOS, turning call_tool and get_tools to DBOS steps."""

pydantic_ai/durable_exec/temporal/_agent.py

@@ -660,7 +660,6 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
             [
                 UserPromptNode(
                     user_prompt='What is the capital of France?',
-                    instructions=None,
                     instructions_functions=[],
                     system_prompts=(),
                     system_prompt_functions=[],

pydantic_ai/durable_exec/temporal/_logfire.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from typing import TYPE_CHECKING
 
-from logfire import Logfire
-from opentelemetry.trace import get_tracer
 from temporalio.client import ClientConfig, Plugin as ClientPlugin
-from temporalio.contrib.opentelemetry import TracingInterceptor
 from temporalio.runtime import OpenTelemetryConfig, Runtime, TelemetryConfig
 from temporalio.service import ConnectConfig, ServiceClient
 
+if TYPE_CHECKING:
+    from logfire import Logfire
+
 
 def _default_setup_logfire() -> Logfire:
     import logfire
@@ -22,6 +23,14 @@ class LogfirePlugin(ClientPlugin):
     """Temporal client plugin for Logfire."""
 
     def __init__(self, setup_logfire: Callable[[], Logfire] = _default_setup_logfire, *, metrics: bool = True):
+        try:
+            import logfire  # noqa: F401 # pyright: ignore[reportUnusedImport]
+        except ImportError as _import_error:
+            raise ImportError(
+                'Please install the `logfire` package to use the Logfire plugin, '
+                'you can use the `logfire` optional group — `pip install "pydantic-ai-slim[logfire]"`'
+            ) from _import_error
+
         self.setup_logfire = setup_logfire
         self.metrics = metrics
 
@@ -29,6 +38,9 @@ class LogfirePlugin(ClientPlugin):
         self.next_client_plugin = next
 
     def configure_client(self, config: ClientConfig) -> ClientConfig:
+        from opentelemetry.trace import get_tracer
+        from temporalio.contrib.opentelemetry import TracingInterceptor
+
         interceptors = config.get('interceptors', [])
         config['interceptors'] = [*interceptors, TracingInterceptor(get_tracer('temporalio'))]
         return self.next_client_plugin.configure_client(config)

pydantic_ai/durable_exec/temporal/_toolset.py

@@ -6,7 +6,6 @@ from typing import Any, Literal
 
 from temporalio.workflow import ActivityConfig
 
-from pydantic_ai.mcp import MCPServer
 from pydantic_ai.tools import AgentDepsT
 from pydantic_ai.toolsets.abstract import AbstractToolset
 from pydantic_ai.toolsets.function import FunctionToolset
@@ -63,16 +62,22 @@ def temporalize_toolset(
             deps_type=deps_type,
             run_context_type=run_context_type,
         )
-    elif isinstance(toolset, MCPServer):
-        from ._mcp_server import TemporalMCPServer
 
-        return TemporalMCPServer(
-            toolset,
-            activity_name_prefix=activity_name_prefix,
-            activity_config=activity_config,
-            tool_activity_config=tool_activity_config,
-            deps_type=deps_type,
-            run_context_type=run_context_type,
-        )
+    try:
+        from pydantic_ai.mcp import MCPServer
+
+        from ._mcp_server import TemporalMCPServer
+    except ImportError:
+        pass
     else:
-        return toolset
+        if isinstance(toolset, MCPServer):
+            return TemporalMCPServer(
+                toolset,
+                activity_name_prefix=activity_name_prefix,
+                activity_config=activity_config,
+                tool_activity_config=tool_activity_config,
+                deps_type=deps_type,
+                run_context_type=run_context_type,
+            )
+
+    return toolset

pydantic_ai/mcp.py

@@ -256,6 +256,11 @@ class MCPServer(AbstractToolset[Any], ABC):
                     name=name,
                     description=mcp_tool.description,
                     parameters_json_schema=mcp_tool.inputSchema,
+                    metadata={
+                        'meta': mcp_tool.meta,
+                        'annotations': mcp_tool.annotations.model_dump() if mcp_tool.annotations else None,
+                        'output_schema': mcp_tool.outputSchema or None,
+                    },
                 ),
             )
             for mcp_tool in await self.list_tools()

pydantic_ai/run.py

@@ -48,7 +48,6 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         [
             UserPromptNode(
                 user_prompt='What is the capital of France?',
-                instructions=None,
                 instructions_functions=[],
                 system_prompts=(),
                 system_prompt_functions=[],
@@ -183,7 +182,6 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
                 [
                     UserPromptNode(
                         user_prompt='What is the capital of France?',
-                        instructions=None,
                         instructions_functions=[],
                         system_prompts=(),
                         system_prompt_functions=[],

pydantic_ai/tools.py

@@ -255,6 +255,7 @@ class Tool(Generic[AgentDepsT]):
     strict: bool | None
     sequential: bool
     requires_approval: bool
+    metadata: dict[str, Any] | None
     function_schema: _function_schema.FunctionSchema
     """
     The base JSON schema for the tool's parameters.
@@ -277,6 +278,7 @@ class Tool(Generic[AgentDepsT]):
         strict: bool | None = None,
         sequential: bool = False,
         requires_approval: bool = False,
+        metadata: dict[str, Any] | None = None,
         function_schema: _function_schema.FunctionSchema | None = None,
     ):
         """Create a new tool instance.
@@ -332,6 +334,7 @@ class Tool(Generic[AgentDepsT]):
             sequential: Whether the function requires a sequential/serial execution environment. Defaults to False.
             requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
                 See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
+            metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization.
             function_schema: The function schema to use for the tool. If not provided, it will be generated.
         """
         self.function = function
@@ -352,6 +355,7 @@ class Tool(Generic[AgentDepsT]):
         self.strict = strict
         self.sequential = sequential
         self.requires_approval = requires_approval
+        self.metadata = metadata
 
     @classmethod
     def from_schema(
@@ -406,6 +410,7 @@ class Tool(Generic[AgentDepsT]):
             parameters_json_schema=self.function_schema.json_schema,
             strict=self.strict,
             sequential=self.sequential,
+            metadata=self.metadata,
         )
 
     async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition | None:
@@ -488,6 +493,12 @@ class ToolDefinition:
         See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
     """
 
+    metadata: dict[str, Any] | None = None
+    """Tool metadata that can be set by the toolset this tool came from. It is not sent to the model, but can be used for filtering and tool behavior customization.
+
+    For MCP tools, this contains the `meta`, `annotations`, and `output_schema` fields from the tool definition.
+    """
+
     @property
     def defer(self) -> bool:
         """Whether calls to this tool will be deferred.

pydantic_ai/toolsets/function.py

@@ -45,18 +45,21 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
         tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = [],
         *,
         max_retries: int = 1,
-        id: str | None = None,
         docstring_format: DocstringFormat = 'auto',
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
+        strict: bool | None = None,
+        sequential: bool = False,
+        requires_approval: bool = False,
+        metadata: dict[str, Any] | None = None,
+        id: str | None = None,
     ):
         """Build a new function toolset.
 
         Args:
             tools: The tools to add to the toolset.
             max_retries: The maximum number of retries for each tool during a run.
-            id: An optional unique ID for the toolset. A toolset needs to have an ID in order to be used in a durable execution environment like Temporal,
-                in which case the ID will be used to identify the toolset's activities within the workflow.
+                Applies to all tools, unless overridden when adding a tool.
             docstring_format: Format of tool docstring, see [`DocstringFormat`][pydantic_ai.tools.DocstringFormat].
                 Defaults to `'auto'`, such that the format is inferred from the structure of the docstring.
                 Applies to all tools, unless overridden when adding a tool.
@@ -64,12 +67,27 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
                 Applies to all tools, unless overridden when adding a tool.
             schema_generator: The JSON schema generator class to use for this tool. Defaults to `GenerateToolJsonSchema`.
                 Applies to all tools, unless overridden when adding a tool.
+            strict: Whether to enforce JSON schema compliance (only affects OpenAI).
+                See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+            sequential: Whether the function requires a sequential/serial execution environment. Defaults to False.
+                Applies to all tools, unless overridden when adding a tool.
+            requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
+                See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
+                Applies to all tools, unless overridden when adding a tool.
+            metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization.
+                Applies to all tools, unless overridden when adding a tool, which will be merged with the toolset's metadata.
+            id: An optional unique ID for the toolset. A toolset needs to have an ID in order to be used in a durable execution environment like Temporal,
+                in which case the ID will be used to identify the toolset's activities within the workflow.
         """
         self.max_retries = max_retries
         self._id = id
         self.docstring_format = docstring_format
         self.require_parameter_descriptions = require_parameter_descriptions
         self.schema_generator = schema_generator
+        self.strict = strict
+        self.sequential = sequential
+        self.requires_approval = requires_approval
+        self.metadata = metadata
 
         self.tools = {}
         for tool in tools:
@@ -97,8 +115,9 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
         require_parameter_descriptions: bool | None = None,
         schema_generator: type[GenerateJsonSchema] | None = None,
         strict: bool | None = None,
-        sequential: bool = False,
-        requires_approval: bool = False,
+        sequential: bool | None = None,
+        requires_approval: bool | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> Callable[[ToolFuncEither[AgentDepsT, ToolParams]], ToolFuncEither[AgentDepsT, ToolParams]]: ...
 
     def tool(
@@ -113,8 +132,9 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
         require_parameter_descriptions: bool | None = None,
         schema_generator: type[GenerateJsonSchema] | None = None,
         strict: bool | None = None,
-        sequential: bool = False,
-        requires_approval: bool = False,
+        sequential: bool | None = None,
+        requires_approval: bool | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> Any:
         """Decorator to register a tool function which takes [`RunContext`][pydantic_ai.tools.RunContext] as its first argument.
 
@@ -163,9 +183,14 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
                 If `None`, the default value is determined by the toolset.
             strict: Whether to enforce JSON schema compliance (only affects OpenAI).
                 See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+                If `None`, the default value is determined by the toolset.
             sequential: Whether the function requires a sequential/serial execution environment. Defaults to False.
+                If `None`, the default value is determined by the toolset.
             requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
                 See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
+                If `None`, the default value is determined by the toolset.
+            metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization.
+                If `None`, the default value is determined by the toolset. If provided, it will be merged with the toolset's metadata.
         """
 
         def tool_decorator(
@@ -184,6 +209,7 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
                 strict,
                 sequential,
                 requires_approval,
+                metadata,
             )
             return func_
 
@@ -200,8 +226,9 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
         require_parameter_descriptions: bool | None = None,
         schema_generator: type[GenerateJsonSchema] | None = None,
         strict: bool | None = None,
-        sequential: bool = False,
-        requires_approval: bool = False,
+        sequential: bool | None = None,
+        requires_approval: bool | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> None:
         """Add a function as a tool to the toolset.
 
@@ -227,9 +254,14 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
                 If `None`, the default value is determined by the toolset.
             strict: Whether to enforce JSON schema compliance (only affects OpenAI).
                 See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
+                If `None`, the default value is determined by the toolset.
             sequential: Whether the function requires a sequential/serial execution environment. Defaults to False.
+                If `None`, the default value is determined by the toolset.
             requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
                 See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
+                If `None`, the default value is determined by the toolset.
+            metadata: Optional metadata for the tool. This is not sent to the model but can be used for filtering and tool behavior customization.
+                If `None`, the default value is determined by the toolset. If provided, it will be merged with the toolset's metadata.
         """
         if docstring_format is None:
             docstring_format = self.docstring_format
@@ -237,6 +269,12 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
             require_parameter_descriptions = self.require_parameter_descriptions
         if schema_generator is None:
             schema_generator = self.schema_generator
+        if strict is None:
+            strict = self.strict
+        if sequential is None:
+            sequential = self.sequential
+        if requires_approval is None:
+            requires_approval = self.requires_approval
 
         tool = Tool[AgentDepsT](
             func,
@@ -250,6 +288,7 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
             strict=strict,
             sequential=sequential,
             requires_approval=requires_approval,
+            metadata=metadata,
         )
         self.add_tool(tool)
 
@@ -263,6 +302,8 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
             raise UserError(f'Tool name conflicts with existing tool: {tool.name!r}')
         if tool.max_retries is None:
             tool.max_retries = self.max_retries
+        if self.metadata is not None:
+            tool.metadata = self.metadata | (tool.metadata or {})
         self.tools[tool.name] = tool
 
     async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:

{pydantic_ai_slim-1.0.6.dist-info → pydantic_ai_slim-1.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.6
+Version: 1.0.7
 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.6
+Requires-Dist: pydantic-graph==1.0.7
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,7 @@ 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.6; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.7; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq