Raise error when tool requiring approval is added without DeferredToolRequests among output types

Author: DouweM

pydantic_ai_slim/pydantic_ai/_agent_graph.py

@@ -788,7 +788,7 @@ async def process_function_tools(  # noqa: C901
                 yield _messages.FunctionToolCallEvent(call)
 
     if not final_result and deferred_calls:
-        if not ctx.deps.output_schema.allows_deferred_tool_requests:
+        if not ctx.deps.output_schema.allows_deferred_tools:
             raise exceptions.UserError(
                 'A deferred tool call was present, but `DeferredToolRequests` is not among output types. To resolve this, add `DeferredToolRequests` to the list of output types for this agent.'
             )

pydantic_ai_slim/pydantic_ai/_output.py

@@ -196,7 +196,7 @@ async def validate(
 
 @dataclass
 class BaseOutputSchema(ABC, Generic[OutputDataT]):
-    allows_deferred_tool_requests: bool
+    allows_deferred_tools: bool
 
     @abstractmethod
     def with_default_mode(self, mode: StructuredOutputMode) -> OutputSchema[OutputDataT]:
@@ -250,8 +250,8 @@ def build(  # noqa: C901
         raw_outputs = _flatten_output_spec(output_spec)
 
         outputs = [output for output in raw_outputs if output is not DeferredToolRequests]
-        allows_deferred_tool_requests = len(outputs) < len(raw_outputs)
-        if len(outputs) == 0 and allows_deferred_tool_requests:
+        allows_deferred_tools = len(outputs) < len(raw_outputs)
+        if len(outputs) == 0 and allows_deferred_tools:
             raise UserError('At least one output type must be provided other than `DeferredToolRequests`.')
 
         if output := next((output for output in outputs if isinstance(output, NativeOutput)), None):
@@ -265,7 +265,7 @@ def build(  # noqa: C901
                     description=output.description,
                     strict=output.strict,
                 ),
-                allows_deferred_tool_requests=allows_deferred_tool_requests,
+                allows_deferred_tools=allows_deferred_tools,
             )
         elif output := next((output for output in outputs if isinstance(output, PromptedOutput)), None):
             if len(outputs) > 1:
@@ -278,7 +278,7 @@ def build(  # noqa: C901
                     description=output.description,
                 ),
                 template=output.template,
-                allows_deferred_tool_requests=allows_deferred_tool_requests,
+                allows_deferred_tools=allows_deferred_tools,
             )
 
         text_outputs: Sequence[type[str] | TextOutput[OutputDataT]] = []
@@ -315,21 +315,19 @@ def build(  # noqa: C901
                 return ToolOrTextOutputSchema(
                     processor=text_output_schema,
                     toolset=toolset,
-                    allows_deferred_tool_requests=allows_deferred_tool_requests,
+                    allows_deferred_tools=allows_deferred_tools,
                 )
             else:
-                return PlainTextOutputSchema(
-                    processor=text_output_schema, allows_deferred_tool_requests=allows_deferred_tool_requests
-                )
+                return PlainTextOutputSchema(processor=text_output_schema, allows_deferred_tools=allows_deferred_tools)
 
         if len(tool_outputs) > 0:
-            return ToolOutputSchema(toolset=toolset, allows_deferred_tool_requests=allows_deferred_tool_requests)
+            return ToolOutputSchema(toolset=toolset, allows_deferred_tools=allows_deferred_tools)
 
         if len(other_outputs) > 0:
             schema = OutputSchemaWithoutMode(
                 processor=cls._build_processor(other_outputs, name=name, description=description, strict=strict),
                 toolset=toolset,
-                allows_deferred_tool_requests=allows_deferred_tool_requests,
+                allows_deferred_tools=allows_deferred_tools,
             )
             if default_mode:
                 schema = schema.with_default_mode(default_mode)
@@ -373,25 +371,19 @@ def __init__(
         self,
         processor: ObjectOutputProcessor[OutputDataT] | UnionOutputProcessor[OutputDataT],
         toolset: OutputToolset[Any] | None,
-        allows_deferred_tool_requests: bool,
+        allows_deferred_tools: bool,
     ):
-        super().__init__(allows_deferred_tool_requests)
+        super().__init__(allows_deferred_tools)
         self.processor = processor
         self._toolset = toolset
 
     def with_default_mode(self, mode: StructuredOutputMode) -> OutputSchema[OutputDataT]:
         if mode == 'native':
-            return NativeOutputSchema(
-                processor=self.processor, allows_deferred_tool_requests=self.allows_deferred_tool_requests
-            )
+            return NativeOutputSchema(processor=self.processor, allows_deferred_tools=self.allows_deferred_tools)
         elif mode == 'prompted':
-            return PromptedOutputSchema(
-                processor=self.processor, allows_deferred_tool_requests=self.allows_deferred_tool_requests
-            )
+            return PromptedOutputSchema(processor=self.processor, allows_deferred_tools=self.allows_deferred_tools)
         elif mode == 'tool':
-            return ToolOutputSchema(
-                toolset=self.toolset, allows_deferred_tool_requests=self.allows_deferred_tool_requests
-            )
+            return ToolOutputSchema(toolset=self.toolset, allows_deferred_tools=self.allows_deferred_tools)
         else:
             assert_never(mode)
 
@@ -554,8 +546,8 @@ async def process(
 class ToolOutputSchema(OutputSchema[OutputDataT]):
     _toolset: OutputToolset[Any] | None
 
-    def __init__(self, toolset: OutputToolset[Any] | None, allows_deferred_tool_requests: bool):
-        super().__init__(allows_deferred_tool_requests)
+    def __init__(self, toolset: OutputToolset[Any] | None, allows_deferred_tools: bool):
+        super().__init__(allows_deferred_tools)
         self._toolset = toolset
 
     @property
@@ -579,9 +571,9 @@ def __init__(
         self,
         processor: PlainTextOutputProcessor[OutputDataT] | None,
         toolset: OutputToolset[Any] | None,
-        allows_deferred_tool_requests: bool,
+        allows_deferred_tools: bool,
     ):
-        super().__init__(toolset=toolset, allows_deferred_tool_requests=allows_deferred_tool_requests)
+        super().__init__(toolset=toolset, allows_deferred_tools=allows_deferred_tools)
         self.processor = processor
 
     @property

pydantic_ai_slim/pydantic_ai/agent/__init__.py

@@ -351,7 +351,9 @@ def __init__(
         if self._output_toolset:
             self._output_toolset.max_retries = self._max_result_retries
 
-        self._function_toolset = _AgentFunctionToolset(tools, max_retries=self._max_tool_retries)
+        self._function_toolset = _AgentFunctionToolset(
+            tools, max_retries=self._max_tool_retries, output_schema=self._output_schema
+        )
         self._dynamic_toolsets = [
             DynamicToolset[AgentDepsT](toolset_func=toolset)
             for toolset in toolsets or []
@@ -1320,7 +1322,9 @@ def toolsets(self) -> Sequence[AbstractToolset[AgentDepsT]]:
         toolsets: list[AbstractToolset[AgentDepsT]] = []
 
         if some_tools := self._override_tools.get():
-            function_toolset = _AgentFunctionToolset(some_tools.value, max_retries=self._max_tool_retries)
+            function_toolset = _AgentFunctionToolset(
+                some_tools.value, max_retries=self._max_tool_retries, output_schema=self._output_schema
+            )
         else:
             function_toolset = self._function_toolset
         toolsets.append(function_toolset)
@@ -1417,10 +1421,30 @@ async def run_mcp_servers(
 
 @dataclasses.dataclass(init=False)
 class _AgentFunctionToolset(FunctionToolset[AgentDepsT]):
+    output_schema: _output.BaseOutputSchema[Any]
+
+    def __init__(
+        self,
+        tools: Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]] = [],
+        max_retries: int = 1,
+        *,
+        id: str | None = None,
+        output_schema: _output.BaseOutputSchema[Any],
+    ):
+        self.output_schema = output_schema
+        super().__init__(tools, max_retries, id=id)
+
     @property
     def id(self) -> str:
         return '<agent>'
 
     @property
     def label(self) -> str:
         return 'the agent'
+
+    def add_tool(self, tool: Tool[AgentDepsT]) -> None:
+        if tool.requires_approval and not self.output_schema.allows_deferred_tools:
+            raise exceptions.UserError(
+                'To use tools that require approval, add `DeferredToolRequests` to the list of output types for this agent.'
+            )
+        super().add_tool(tool)

pydantic_ai_slim/pydantic_ai/result.py

@@ -157,7 +157,7 @@ async def validate_response_output(
                 tool_call, allow_partial=allow_partial, wrap_validation_errors=False
             )
         elif deferred_tool_requests := _get_deferred_tool_requests(message.parts, self._tool_manager):
-            if not self._output_schema.allows_deferred_tool_requests:
+            if not self._output_schema.allows_deferred_tools:
                 raise exceptions.UserError(
                     'A deferred tool call was present, but `DeferredToolRequests` is not among output types. To resolve this, add `DeferredToolRequests` to the list of output types for this agent.'
                 )

tests/test_agent.py

@@ -4617,3 +4617,16 @@ async def test_run_with_deferred_tool_results_errors():
                 calls={'run_me_too': 'Success', 'defer_me': 'Failure'},
             ),
         )
+
+
+def test_tool_requires_approval_error():
+    agent = Agent('test')
+
+    with pytest.raises(
+        UserError,
+        match='To use tools that require approval, add `DeferredToolRequests` to the list of output types for this agent.',
+    ):
+
+        @agent.tool_plain(requires_approval=True)
+        def delete_file(path: str) -> None:
+            pass