Emit tool-output-denied chunk and document v6 requirements

bendrucker · bendrucker · commit 52fb5d1bd695 · 2025-12-18T20:47:26.000-08:00
diff --git a/docs/ui/vercel-ai.md b/docs/ui/vercel-ai.md
@@ -2,6 +2,9 @@
 
 Pydantic AI natively supports the [Vercel AI Data Stream Protocol](https://ai-sdk.dev/docs/ai-sdk-ui/stream-protocol#data-stream-protocol) to receive agent run input from, and stream events to, a [Vercel AI Elements](https://ai-sdk.dev/elements) frontend.
 
+!!! note "AI SDK Version Compatibility"
+    The base protocol is compatible with AI SDK v5 and later. However, [tool approval](#tool-approval) (human-in-the-loop) features require **AI SDK v6 or later**.
+
 ## Usage
 
 The [`VercelAIAdapter`][pydantic_ai.ui.vercel_ai.VercelAIAdapter] class is responsible for transforming agent run input received from the frontend into arguments for [`Agent.run_stream_events()`](../agents.md#running-agents), running the agent, and then transforming Pydantic AI events into Vercel AI events. The event stream transformation is handled by the [`VercelAIEventStream`][pydantic_ai.ui.vercel_ai.VercelAIEventStream] class, but you typically won't use this directly.
@@ -81,3 +84,58 @@ async def chat(request: Request) -> Response:
     sse_event_stream = adapter.encode_stream(event_stream)
     return StreamingResponse(sse_event_stream, media_type=accept)
 ```
+
+## Tool Approval
+
+Pydantic AI supports [AI SDK's human-in-the-loop tool approval](https://ai-sdk.dev/cookbook/next/human-in-the-loop) workflow, allowing users to approve or deny tool executions before they run.
+
+!!! warning "Requires AI SDK v6"
+    Tool approval is an AI SDK v6 feature. The `tool-approval-request` and `tool-output-denied` stream chunks, along with the `approval` field on tool parts, are not available in AI SDK v5.
+
+### How It Works
+
+1. **Tool requests approval**: When an agent calls a tool with `requires_approval=True`, Pydantic AI emits a `tool-approval-request` chunk instead of executing the tool immediately.
+
+2. **User decides**: The AI SDK frontend displays an approval UI. The user can approve or deny the tool execution.
+
+3. **Response is sent**: The frontend sends the approval decision back to the server in a follow-up request.
+
+4. **Tool executes or is denied**: If approved, the tool runs normally. If denied, Pydantic AI emits a `tool-output-denied` chunk and informs the model that the tool was rejected.
+
+### Server-Side Setup
+
+To enable tool approval, define your tool with `requires_approval=True` and include [`DeferredToolRequests`][pydantic_ai.tools.DeferredToolRequests] in your agent's output types:
+
+```py
+from pydantic_ai import Agent
+from pydantic_ai.tools import DeferredToolRequests
+
+agent: Agent[None, str | DeferredToolRequests] = Agent(
+    'openai:gpt-5',
+    output_type=[str, DeferredToolRequests],
+)
+
+@agent.tool_plain(requires_approval=True)
+def delete_file(path: str) -> str:
+    """Delete a file from the filesystem."""
+    # This won't execute until the user approves
+    os.remove(path)
+    return f'Deleted {path}'
+```
+
+When processing a follow-up request with approval responses, extract and pass the deferred tool results:
+
+```py
+@app.post('/chat')
+async def chat(request: Request) -> Response:
+    adapter = await VercelAIAdapter.from_request(request, agent=agent)
+    return adapter.streaming_response(
+        adapter.run_stream(deferred_tool_results=adapter.deferred_tool_results)
+    )
+```
+
+### Client-Side Setup
+
+On the frontend, use AI SDK v6's [`useChat`](https://v6.ai-sdk.dev/docs/ai-sdk-ui/use-chat) hook with the [`Confirmation`](https://ai-sdk.dev/elements/components/confirmation) component or the `addToolApprovalResponse` function to handle approval UI.
+
+See the [AI SDK Human-in-the-Loop Cookbook](https://ai-sdk.dev/cookbook/next/human-in-the-loop) for complete frontend examples.
diff --git a/pydantic_ai_slim/pydantic_ai/ui/vercel_ai/_event_stream.py b/pydantic_ai_slim/pydantic_ai/ui/vercel_ai/_event_stream.py
@@ -28,7 +28,13 @@
 from ...run import AgentRunResultEvent
 from ...tools import AgentDepsT, DeferredToolRequests
 from .. import UIEventStream
-from .request_types import RequestData
+from .request_types import (
+    DynamicToolUIPart,
+    RequestData,
+    ToolApprovalResponded,
+    ToolUIPart,
+    UIMessage,
+)
 from .response_types import (
     BaseChunk,
     DoneChunk,
@@ -50,6 +56,7 @@
     ToolInputDeltaChunk,
     ToolInputStartChunk,
     ToolOutputAvailableChunk,
+    ToolOutputDeniedChunk,
     ToolOutputErrorChunk,
 )
 
@@ -73,12 +80,35 @@ def _json_dumps(obj: Any) -> str:
     return to_json(obj).decode('utf-8')
 
 
+def _extract_denied_tool_ids(messages: list[UIMessage]) -> set[str]:
+    """Extract tool_call_ids that were denied from UI messages."""
+    denied_ids: set[str] = set()
+    for msg in messages:
+        if msg.role != 'assistant':
+            continue
+        for part in msg.parts:
+            if not isinstance(part, ToolUIPart | DynamicToolUIPart):
+                continue
+            approval = part.approval
+            if isinstance(approval, ToolApprovalResponded) and not approval.approved:
+                denied_ids.add(part.tool_call_id)
+    return denied_ids
+
+
 @dataclass
 class VercelAIEventStream(UIEventStream[RequestData, BaseChunk, AgentDepsT, OutputDataT]):
     """UI event stream transformer for the Vercel AI protocol."""
 
     _step_started: bool = False
     _finish_reason: FinishReason = None
+    _denied_tool_ids: set[str] | None = None
+
+    @property
+    def denied_tool_ids(self) -> set[str]:
+        """Get the set of tool_call_ids that were denied by the user."""
+        if self._denied_tool_ids is None:
+            self._denied_tool_ids = _extract_denied_tool_ids(self.run_input.messages)
+        return self._denied_tool_ids
 
     @property
     def response_headers(self) -> Mapping[str, str] | None:
@@ -212,10 +242,15 @@ async def handle_file(self, part: FilePart) -> AsyncIterator[BaseChunk]:
 
     async def handle_function_tool_result(self, event: FunctionToolResultEvent) -> AsyncIterator[BaseChunk]:
         part = event.result
-        if isinstance(part, RetryPromptPart):
-            yield ToolOutputErrorChunk(tool_call_id=part.tool_call_id, error_text=part.model_response())
+        tool_call_id = part.tool_call_id
+
+        # Check if this tool was denied by the user
+        if tool_call_id in self.denied_tool_ids:
+            yield ToolOutputDeniedChunk(tool_call_id=tool_call_id)
+        elif isinstance(part, RetryPromptPart):
+            yield ToolOutputErrorChunk(tool_call_id=tool_call_id, error_text=part.model_response())
         else:
-            yield ToolOutputAvailableChunk(tool_call_id=part.tool_call_id, output=self._tool_return_output(part))
+            yield ToolOutputAvailableChunk(tool_call_id=tool_call_id, output=self._tool_return_output(part))
 
         # ToolCallResultEvent.content may hold user parts (e.g. text, images) that Vercel AI does not currently have events for
 
diff --git a/pydantic_ai_slim/pydantic_ai/ui/vercel_ai/request_types.py b/pydantic_ai_slim/pydantic_ai/ui/vercel_ai/request_types.py
@@ -1,7 +1,9 @@
 """Vercel AI request types (UI messages).
 
 Converted to Python from:
-https://github.com/vercel/ai/blob/ai%405.0.59/packages/ai/src/ui/ui-messages.ts
+https://github.com/vercel/ai/blob/ai%406.0.0-beta.159/packages/ai/src/ui/ui-messages.ts
+
+Tool approval types (`ToolApprovalRequested`, `ToolApprovalResponded`) require AI SDK v6 or later.
 """
 
 from abc import ABC
diff --git a/pydantic_ai_slim/pydantic_ai/ui/vercel_ai/response_types.py b/pydantic_ai_slim/pydantic_ai/ui/vercel_ai/response_types.py
@@ -1,7 +1,9 @@
 """Vercel AI response types (SSE chunks).
 
 Converted to Python from:
-https://github.com/vercel/ai/blob/ai%405.0.59/packages/ai/src/ui-message-stream/ui-message-chunks.ts
+https://github.com/vercel/ai/blob/ai%406.0.0-beta.159/packages/ai/src/ui-message-stream/ui-message-chunks.ts
+
+Tool approval types (`ToolApprovalRequestChunk`, `ToolOutputDeniedChunk`) require AI SDK v6 or later.
 """
 
 from abc import ABC
diff --git a/tests/test_vercel_ai.py b/tests/test_vercel_ai.py
@@ -1749,9 +1749,7 @@ def test_extract_deferred_tool_results_denied():
                     tool_name='delete_file',
                     tool_call_id='delete_1',
                     input={'path': 'test.txt'},
-                    approval=ToolApprovalResponded(
-                        id='approval-123', approved=False, reason='User rejected deletion'
-                    ),
+                    approval=ToolApprovalResponded(id='approval-123', approved=False, reason='User rejected deletion'),
                 ),
             ],
         ),
@@ -1779,6 +1777,74 @@ def test_extract_deferred_tool_results_no_approvals():
     assert result is None
 
 
+async def test_tool_output_denied_chunk_emission():
+    """Test that ToolOutputDeniedChunk is emitted when a tool call is denied."""
+    from pydantic_ai.tools import DeferredToolRequests
+
+    from pydantic_ai.ui.vercel_ai.request_types import (
+        DynamicToolInputAvailablePart,
+        ToolApprovalResponded,
+    )
+
+    async def stream_function(
+        messages: list[ModelMessage], agent_info: AgentInfo
+    ) -> AsyncIterator[DeltaToolCalls | str]:
+        # Model acknowledges the denial
+        yield 'The file deletion was cancelled as requested.'
+
+    agent: Agent[None, str | DeferredToolRequests] = Agent(
+        model=FunctionModel(stream_function=stream_function), output_type=[str, DeferredToolRequests]
+    )
+
+    @agent.tool_plain(requires_approval=True)
+    def delete_file(path: str) -> str:
+        return f'Deleted {path}'
+
+    # Simulate a follow-up request where the user denied the tool
+    request = SubmitMessage(
+        id='foo',
+        messages=[
+            UIMessage(
+                id='user-1',
+                role='user',
+                parts=[TextUIPart(text='Delete test.txt')],
+            ),
+            UIMessage(
+                id='assistant-1',
+                role='assistant',
+                parts=[
+                    DynamicToolInputAvailablePart(
+                        tool_name='delete_file',
+                        tool_call_id='delete_1',
+                        input={'path': 'test.txt'},
+                        approval=ToolApprovalResponded(
+                            id='approval-123',
+                            approved=False,
+                            reason='User cancelled the deletion',
+                        ),
+                    ),
+                ],
+            ),
+        ],
+    )
+
+    adapter = VercelAIAdapter(agent, request)
+    events: list[str | dict[str, Any]] = [
+        '[DONE]' if '[DONE]' in event else json.loads(event.removeprefix('data: '))
+        async for event in adapter.encode_stream(
+            adapter.run_stream(deferred_tool_results=adapter.deferred_tool_results)
+        )
+    ]
+
+    # Verify tool-output-denied chunk is emitted
+    denied_event: dict[str, Any] | None = next(
+        (e for e in events if isinstance(e, dict) and e.get('type') == 'tool-output-denied'),
+        None,
+    )
+    assert denied_event is not None
+    assert denied_event['toolCallId'] == 'delete_1'
+
+
 @pytest.mark.skipif(not starlette_import_successful, reason='Starlette is not installed')
 async def test_adapter_dispatch_request():
     agent = Agent(model=TestModel())
@@ -2217,6 +2283,7 @@ async def test_adapter_dump_messages_with_tools():
                         'output': '{"results":["result1","result2"]}',
                         'call_provider_metadata': None,
                         'preliminary': None,
+                        'approval': None,
                     },
                 ],
             },
@@ -2279,6 +2346,7 @@ async def test_adapter_dump_messages_with_builtin_tools():
                         'provider_executed': True,
                         'call_provider_metadata': {'pydantic_ai': {'provider_name': 'openai'}},
                         'preliminary': None,
+                        'approval': None,
                     }
                 ],
             },
@@ -2325,6 +2393,7 @@ async def test_adapter_dump_messages_with_builtin_tool_without_return():
                         'input': '{"query":"orphan query"}',
                         'provider_executed': True,
                         'call_provider_metadata': {'pydantic_ai': {'provider_name': 'openai'}},
+                        'approval': None,
                     }
                 ],
             },
@@ -2491,6 +2560,7 @@ async def test_adapter_dump_messages_with_retry():
 Fix the errors and try again.\
 """,
                         'call_provider_metadata': None,
+                        'approval': None,
                     }
                 ],
             },
@@ -2622,6 +2692,7 @@ async def test_adapter_dump_messages_text_with_interruption():
                         'provider_executed': True,
                         'call_provider_metadata': {'pydantic_ai': {'provider_name': 'test'}},
                         'preliminary': None,
+                        'approval': None,
                     },
                     {
                         'type': 'text',
@@ -2740,6 +2811,7 @@ async def test_adapter_dump_messages_tool_call_without_return():
                         'state': 'input-available',
                         'input': '{"city":"New York"}',
                         'call_provider_metadata': None,
+                        'approval': None,
                     }
                 ],
             }
@@ -2774,6 +2846,7 @@ async def test_adapter_dump_messages_assistant_starts_with_tool():
                         'state': 'input-available',
                         'input': '{}',
                         'call_provider_metadata': None,
+                        'approval': None,
                     },
                     {
                         'type': 'text',
