pydantic-ai-slim 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

pydantic_ai/mcp.py

@@ -7,7 +7,7 @@ from abc import ABC, abstractmethod
 from asyncio import Lock
 from collections.abc import AsyncIterator, Awaitable, Sequence
 from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager
-from dataclasses import dataclass, field, replace
+from dataclasses import field, replace
 from datetime import timedelta
 from pathlib import Path
 from typing import Any, Callable
@@ -56,17 +56,17 @@ class MCPServer(AbstractToolset[Any], ABC):
     See <https://modelcontextprotocol.io> for more information.
     """
 
-    # these fields should be re-defined by dataclass subclasses so they appear as fields {
-    tool_prefix: str | None = None
-    log_level: mcp_types.LoggingLevel | None = None
-    log_handler: LoggingFnT | None = None
-    timeout: float = 5
-    read_timeout: float = 5 * 60
-    process_tool_call: ProcessToolCallback | None = None
-    allow_sampling: bool = True
-    max_retries: int = 1
-    sampling_model: models.Model | None = None
-    # } end of "abstract fields"
+    tool_prefix: str | None
+    log_level: mcp_types.LoggingLevel | None
+    log_handler: LoggingFnT | None
+    timeout: float
+    read_timeout: float
+    process_tool_call: ProcessToolCallback | None
+    allow_sampling: bool
+    sampling_model: models.Model | None
+    max_retries: int
+
+    _id: str | None
 
     _enter_lock: Lock = field(compare=False)
     _running_count: int
@@ -76,6 +76,34 @@ class MCPServer(AbstractToolset[Any], ABC):
     _read_stream: MemoryObjectReceiveStream[SessionMessage | Exception]
     _write_stream: MemoryObjectSendStream[SessionMessage]
 
+    def __init__(
+        self,
+        tool_prefix: str | None = None,
+        log_level: mcp_types.LoggingLevel | None = None,
+        log_handler: LoggingFnT | None = None,
+        timeout: float = 5,
+        read_timeout: float = 5 * 60,
+        process_tool_call: ProcessToolCallback | None = None,
+        allow_sampling: bool = True,
+        sampling_model: models.Model | None = None,
+        max_retries: int = 1,
+        *,
+        id: str | None = None,
+    ):
+        self.tool_prefix = tool_prefix
+        self.log_level = log_level
+        self.log_handler = log_handler
+        self.timeout = timeout
+        self.read_timeout = read_timeout
+        self.process_tool_call = process_tool_call
+        self.allow_sampling = allow_sampling
+        self.sampling_model = sampling_model
+        self.max_retries = max_retries
+
+        self._id = id or tool_prefix
+
+        self.__post_init__()
+
     def __post_init__(self):
         self._enter_lock = Lock()
         self._running_count = 0
@@ -96,12 +124,19 @@ class MCPServer(AbstractToolset[Any], ABC):
         yield
 
     @property
-    def name(self) -> str:
-        return repr(self)
+    def id(self) -> str | None:
+        return self._id
+
+    @property
+    def label(self) -> str:
+        if self.id:
+            return super().label  # pragma: no cover
+        else:
+            return repr(self)
 
     @property
     def tool_name_conflict_hint(self) -> str:
-        return 'Consider setting `tool_prefix` to avoid name conflicts.'
+        return 'Set the `tool_prefix` attribute to avoid name conflicts.'
 
     async def list_tools(self) -> list[mcp_types.Tool]:
         """Retrieve tools that are currently active on the server.
@@ -177,20 +212,25 @@ class MCPServer(AbstractToolset[Any], ABC):
 
     async def get_tools(self, ctx: RunContext[Any]) -> dict[str, ToolsetTool[Any]]:
         return {
-            name: ToolsetTool(
-                toolset=self,
-                tool_def=ToolDefinition(
+            name: self.tool_for_tool_def(
+                ToolDefinition(
                     name=name,
                     description=mcp_tool.description,
                     parameters_json_schema=mcp_tool.inputSchema,
                 ),
-                max_retries=self.max_retries,
-                args_validator=TOOL_SCHEMA_VALIDATOR,
             )
             for mcp_tool in await self.list_tools()
             if (name := f'{self.tool_prefix}_{mcp_tool.name}' if self.tool_prefix else mcp_tool.name)
         }
 
+    def tool_for_tool_def(self, tool_def: ToolDefinition) -> ToolsetTool[Any]:
+        return ToolsetTool(
+            toolset=self,
+            tool_def=tool_def,
+            max_retries=self.max_retries,
+            args_validator=TOOL_SCHEMA_VALIDATOR,
+        )
+
     async def __aenter__(self) -> Self:
         """Enter the MCP server context.
 
@@ -308,7 +348,6 @@ class MCPServer(AbstractToolset[Any], ABC):
             assert_never(resource)
 
 
-@dataclass
 class MCPServerStdio(MCPServer):
     """Runs an MCP server in a subprocess and communicates with it over stdin/stdout.
 
@@ -353,18 +392,18 @@ class MCPServerStdio(MCPServer):
     args: Sequence[str]
     """The arguments to pass to the command."""
 
-    env: dict[str, str] | None = None
+    env: dict[str, str] | None
     """The environment variables the CLI server will have access to.
 
     By default the subprocess will not inherit any environment variables from the parent process.
     If you want to inherit the environment variables from the parent process, use `env=os.environ`.
     """
 
-    cwd: str | Path | None = None
+    cwd: str | Path | None
     """The working directory to use when spawning the process."""
 
     # last fields are re-defined from the parent class so they appear as fields
-    tool_prefix: str | None = None
+    tool_prefix: str | None
     """A prefix to add to all tools that are registered with the server.
 
     If not empty, will include a trailing underscore(`_`).
@@ -372,7 +411,7 @@ class MCPServerStdio(MCPServer):
     e.g. if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
     """
 
-    log_level: mcp_types.LoggingLevel | None = None
+    log_level: mcp_types.LoggingLevel | 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.
@@ -380,23 +419,85 @@ class MCPServerStdio(MCPServer):
     If `None`, no log level will be set.
     """
 
-    log_handler: LoggingFnT | None = None
+    log_handler: LoggingFnT | None
     """A handler for logging messages from the server."""
 
-    timeout: float = 5
+    timeout: float
     """The timeout in seconds to wait for the client to initialize."""
 
-    process_tool_call: ProcessToolCallback | None = None
+    read_timeout: float
+    """Maximum time in seconds to wait for new messages before timing out.
+
+    This timeout applies to the long-lived connection after it's established.
+    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).
+    """
+
+    process_tool_call: ProcessToolCallback | None
     """Hook to customize tool calling and optionally pass extra metadata."""
 
-    allow_sampling: bool = True
+    allow_sampling: bool
     """Whether to allow MCP sampling through this client."""
 
-    max_retries: int = 1
+    sampling_model: models.Model | None
+    """The model to use for sampling."""
+
+    max_retries: int
     """The maximum number of times to retry a tool call."""
 
-    sampling_model: models.Model | None = None
-    """The model to use for sampling."""
+    def __init__(
+        self,
+        command: str,
+        args: Sequence[str],
+        env: dict[str, str] | None = None,
+        cwd: str | Path | None = None,
+        tool_prefix: str | None = None,
+        log_level: mcp_types.LoggingLevel | None = None,
+        log_handler: LoggingFnT | None = None,
+        timeout: float = 5,
+        read_timeout: float = 5 * 60,
+        process_tool_call: ProcessToolCallback | None = None,
+        allow_sampling: bool = True,
+        sampling_model: models.Model | None = None,
+        max_retries: int = 1,
+        *,
+        id: str | None = None,
+    ):
+        """Build a new MCP server.
+
+        Args:
+            command: The command to run.
+            args: The arguments to pass to the command.
+            env: The environment variables to set in the subprocess.
+            cwd: The working directory to use when spawning the process.
+            tool_prefix: A prefix to add to all tools that are registered with the server.
+            log_level: The log level to set when connecting to the server, if any.
+            log_handler: A handler for logging messages from the server.
+            timeout: The timeout in seconds to wait for the client to initialize.
+            read_timeout: Maximum time in seconds to wait for new messages before timing out.
+            process_tool_call: Hook to customize tool calling and optionally pass extra metadata.
+            allow_sampling: Whether to allow MCP sampling through this client.
+            sampling_model: The model to use for sampling.
+            max_retries: The maximum number of times to retry a tool call.
+            id: An optional unique ID for the MCP server. An MCP server 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 server's activities within the workflow.
+        """
+        self.command = command
+        self.args = args
+        self.env = env
+        self.cwd = cwd
+
+        super().__init__(
+            tool_prefix,
+            log_level,
+            log_handler,
+            timeout,
+            read_timeout,
+            process_tool_call,
+            allow_sampling,
+            sampling_model,
+            max_retries,
+            id=id,
+        )
 
     @asynccontextmanager
     async def client_streams(
@@ -412,15 +513,20 @@ class MCPServerStdio(MCPServer):
             yield read_stream, write_stream
 
     def __repr__(self) -> str:
-        return f'MCPServerStdio(command={self.command!r}, args={self.args!r}, tool_prefix={self.tool_prefix!r})'
+        repr_args = [
+            f'command={self.command!r}',
+            f'args={self.args!r}',
+        ]
+        if self.id:
+            repr_args.append(f'id={self.id!r}')  # pragma: no cover
+        return f'{self.__class__.__name__}({", ".join(repr_args)})'
 
 
-@dataclass(init=False)
 class _MCPServerHTTP(MCPServer):
     url: str
     """The URL of the endpoint on the MCP server."""
 
-    headers: dict[str, Any] | None = None
+    headers: dict[str, Any] | None
     """Optional HTTP headers to be sent with each request to the endpoint.
 
     These headers will be passed directly to the underlying `httpx.AsyncClient`.
@@ -432,7 +538,7 @@ class _MCPServerHTTP(MCPServer):
         See [`MCPServerHTTP.http_client`][pydantic_ai.mcp.MCPServerHTTP.http_client] for more information.
     """
 
-    http_client: httpx.AsyncClient | None = None
+    http_client: httpx.AsyncClient | None
     """An `httpx.AsyncClient` to use with the endpoint.
 
     This client may be configured to use customized connection parameters like self-signed certificates.
@@ -452,16 +558,8 @@ class _MCPServerHTTP(MCPServer):
         ```
     """
 
-    read_timeout: float = 5 * 60
-    """Maximum time in seconds to wait for new messages before timing out.
-
-    This timeout applies to the long-lived connection after it's established.
-    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).
-    """
-
     # last fields are re-defined from the parent class so they appear as fields
-    tool_prefix: str | None = None
+    tool_prefix: str | None
     """A prefix to add to all tools that are registered with the server.
 
     If not empty, will include a trailing underscore (`_`).
@@ -469,7 +567,7 @@ class _MCPServerHTTP(MCPServer):
     For example, if `tool_prefix='foo'`, then a tool named `bar` will be registered as `foo_bar`
     """
 
-    log_level: mcp_types.LoggingLevel | None = None
+    log_level: mcp_types.LoggingLevel | None
     """The log level to set when connecting to the server, if any.
 
     See <https://modelcontextprotocol.io/introduction#logging> for more details.
@@ -477,56 +575,81 @@ class _MCPServerHTTP(MCPServer):
     If `None`, no log level will be set.
     """
 
-    log_handler: LoggingFnT | None = None
+    log_handler: LoggingFnT | None
     """A handler for logging messages from the server."""
 
-    timeout: float = 5
+    timeout: float
     """Initial connection timeout in seconds for establishing the connection.
 
     This timeout applies to the initial connection setup and handshake.
     If the connection cannot be established within this time, the operation will fail.
     """
 
-    process_tool_call: ProcessToolCallback | None = None
+    read_timeout: float
+    """Maximum time in seconds to wait for new messages before timing out.
+
+    This timeout applies to the long-lived connection after it's established.
+    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).
+    """
+
+    process_tool_call: ProcessToolCallback | None
     """Hook to customize tool calling and optionally pass extra metadata."""
 
-    allow_sampling: bool = True
+    allow_sampling: bool
     """Whether to allow MCP sampling through this client."""
 
-    max_retries: int = 1
-    """The maximum number of times to retry a tool call."""
-
-    sampling_model: models.Model | None = None
+    sampling_model: models.Model | None
     """The model to use for sampling."""
 
+    max_retries: int
+    """The maximum number of times to retry a tool call."""
+
     def __init__(
         self,
         *,
         url: str,
         headers: dict[str, str] | None = None,
         http_client: httpx.AsyncClient | None = None,
-        read_timeout: float | None = None,
+        id: str | None = None,
         tool_prefix: str | None = None,
         log_level: mcp_types.LoggingLevel | None = None,
         log_handler: LoggingFnT | None = None,
         timeout: float = 5,
+        read_timeout: float | None = None,
         process_tool_call: ProcessToolCallback | None = None,
         allow_sampling: bool = True,
-        max_retries: int = 1,
         sampling_model: models.Model | None = None,
-        **kwargs: Any,
+        max_retries: int = 1,
+        **_deprecated_kwargs: Any,
     ):
-        # Handle deprecated sse_read_timeout parameter
-        if 'sse_read_timeout' in kwargs:
+        """Build a new MCP server.
+
+        Args:
+            url: The URL of the endpoint on the MCP server.
+            headers: Optional HTTP headers to be sent with each request to the endpoint.
+            http_client: An `httpx.AsyncClient` to use with the endpoint.
+            id: An optional unique ID for the MCP server. An MCP server 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 server's activities within the workflow.
+            tool_prefix: A prefix to add to all tools that are registered with the server.
+            log_level: The log level to set when connecting to the server, if any.
+            log_handler: A handler for logging messages from the server.
+            timeout: The timeout in seconds to wait for the client to initialize.
+            read_timeout: Maximum time in seconds to wait for new messages before timing out.
+            process_tool_call: Hook to customize tool calling and optionally pass extra metadata.
+            allow_sampling: Whether to allow MCP sampling through this client.
+            sampling_model: The model to use for sampling.
+            max_retries: The maximum number of times to retry a tool call.
+        """
+        if 'sse_read_timeout' in _deprecated_kwargs:
             if read_timeout is not None:
                 raise TypeError("'read_timeout' and 'sse_read_timeout' cannot be set at the same time.")
 
             warnings.warn(
                 "'sse_read_timeout' is deprecated, use 'read_timeout' instead.", DeprecationWarning, stacklevel=2
             )
-            read_timeout = kwargs.pop('sse_read_timeout')
+            read_timeout = _deprecated_kwargs.pop('sse_read_timeout')
 
-        _utils.validate_empty_kwargs(kwargs)
+        _utils.validate_empty_kwargs(_deprecated_kwargs)
 
         if read_timeout is None:
             read_timeout = 5 * 60
@@ -534,16 +657,19 @@ class _MCPServerHTTP(MCPServer):
         self.url = url
         self.headers = headers
         self.http_client = http_client
-        self.tool_prefix = tool_prefix
-        self.log_level = log_level
-        self.log_handler = log_handler
-        self.timeout = timeout
-        self.process_tool_call = process_tool_call
-        self.allow_sampling = allow_sampling
-        self.max_retries = max_retries
-        self.sampling_model = sampling_model
-        self.read_timeout = read_timeout
-        self.__post_init__()
+
+        super().__init__(
+            tool_prefix,
+            log_level,
+            log_handler,
+            timeout,
+            read_timeout,
+            process_tool_call,
+            allow_sampling,
+            sampling_model,
+            max_retries,
+            id=id,
+        )
 
     @property
     @abstractmethod
@@ -606,10 +732,14 @@ class _MCPServerHTTP(MCPServer):
                 yield read_stream, write_stream
 
     def __repr__(self) -> str:  # pragma: no cover
-        return f'{self.__class__.__name__}(url={self.url!r}, tool_prefix={self.tool_prefix!r})'
+        repr_args = [
+            f'url={self.url!r}',
+        ]
+        if self.id:
+            repr_args.append(f'id={self.id!r}')
+        return f'{self.__class__.__name__}({", ".join(repr_args)})'
 
 
-@dataclass(init=False)
 class MCPServerSSE(_MCPServerHTTP):
     """An MCP server that connects over streamable HTTP connections.
 
@@ -643,7 +773,6 @@ class MCPServerSSE(_MCPServerHTTP):
 
 
 @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.
 
@@ -672,7 +801,6 @@ class MCPServerHTTP(MCPServerSSE):
     """
 
 
-@dataclass
 class MCPServerStreamableHTTP(_MCPServerHTTP):
     """An MCP server that connects over HTTP using the Streamable HTTP transport.
 

pydantic_ai/messages.py

@@ -490,8 +490,8 @@ _video_format_lookup: dict[str, VideoFormat] = {
 class UserPromptPart:
     """A user prompt, generally written by the end user.
 
-    Content comes from the `user_prompt` parameter of [`Agent.run`][pydantic_ai.Agent.run],
-    [`Agent.run_sync`][pydantic_ai.Agent.run_sync], and [`Agent.run_stream`][pydantic_ai.Agent.run_stream].
+    Content comes from the `user_prompt` parameter of [`Agent.run`][pydantic_ai.agent.AbstractAgent.run],
+    [`Agent.run_sync`][pydantic_ai.agent.AbstractAgent.run_sync], and [`Agent.run_stream`][pydantic_ai.agent.AbstractAgent.run_stream].
     """
 
     content: str | Sequence[UserContent]

pydantic_ai/models/__init__.py

@@ -13,20 +13,32 @@ from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field, replace
 from datetime import datetime
 from functools import cache, cached_property
-from typing import Generic, TypeVar, overload
+from typing import Any, Generic, TypeVar, overload
 
 import httpx
 from typing_extensions import Literal, TypeAliasType, TypedDict
 
-from pydantic_ai.builtin_tools import AbstractBuiltinTool
-from pydantic_ai.profiles import DEFAULT_PROFILE, ModelProfile, ModelProfileSpec
-
 from .. import _utils
 from .._output import OutputObjectDefinition
 from .._parts_manager import ModelResponsePartsManager
+from .._run_context import RunContext
+from ..builtin_tools import AbstractBuiltinTool
 from ..exceptions import UserError
-from ..messages import FileUrl, ModelMessage, ModelRequest, ModelResponse, ModelResponseStreamEvent, VideoUrl
+from ..messages import (
+    AgentStreamEvent,
+    FileUrl,
+    FinalResultEvent,
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    ModelResponseStreamEvent,
+    PartStartEvent,
+    TextPart,
+    ToolCallPart,
+    VideoUrl,
+)
 from ..output import OutputMode
+from ..profiles import DEFAULT_PROFILE, ModelProfile, ModelProfileSpec
 from ..profiles._json_schema import JsonSchemaTransformer
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
@@ -344,6 +356,10 @@ class ModelRequestParameters:
     output_tools: list[ToolDefinition] = field(default_factory=list)
     allow_text_output: bool = True
 
+    @cached_property
+    def tool_defs(self) -> dict[str, ToolDefinition]:
+        return {tool_def.name: tool_def for tool_def in [*self.function_tools, *self.output_tools]}
+
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
@@ -389,6 +405,7 @@ class Model(ABC):
         messages: list[ModelMessage],
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
+        run_context: RunContext[Any] | None = None,
     ) -> AsyncIterator[StreamedResponse]:
         """Make a request to the model and return a streaming response."""
         # This method is not required, but you need to implement it if you want to support streamed responses
@@ -501,14 +518,40 @@ class Model(ABC):
 class StreamedResponse(ABC):
     """Streamed response from an LLM when calling a tool."""
 
+    model_request_parameters: ModelRequestParameters
+    final_result_event: FinalResultEvent | None = field(default=None, init=False)
+
     _parts_manager: ModelResponsePartsManager = field(default_factory=ModelResponsePartsManager, init=False)
-    _event_iterator: AsyncIterator[ModelResponseStreamEvent] | None = field(default=None, init=False)
+    _event_iterator: AsyncIterator[AgentStreamEvent] | None = field(default=None, init=False)
     _usage: Usage = field(default_factory=Usage, init=False)
 
-    def __aiter__(self) -> AsyncIterator[ModelResponseStreamEvent]:
-        """Stream the response as an async iterable of [`ModelResponseStreamEvent`][pydantic_ai.messages.ModelResponseStreamEvent]s."""
+    def __aiter__(self) -> AsyncIterator[AgentStreamEvent]:
+        """Stream the response as an async iterable of [`AgentStreamEvent`][pydantic_ai.messages.AgentStreamEvent]s.
+
+        This proxies the `_event_iterator()` and emits all events, while also checking for matches
+        on the result schema and emitting a [`FinalResultEvent`][pydantic_ai.messages.FinalResultEvent] if/when the
+        first match is found.
+        """
         if self._event_iterator is None:
-            self._event_iterator = self._get_event_iterator()
+
+            async def iterator_with_final_event(
+                iterator: AsyncIterator[ModelResponseStreamEvent],
+            ) -> AsyncIterator[AgentStreamEvent]:
+                async for event in iterator:
+                    yield event
+                    if (
+                        final_result_event := _get_final_result_event(event, self.model_request_parameters)
+                    ) is not None:
+                        self.final_result_event = final_result_event
+                        yield final_result_event
+                        break
+
+                # If we broke out of the above loop, we need to yield the rest of the events
+                # If we didn't, this will just be a no-op
+                async for event in iterator:
+                    yield event
+
+            self._event_iterator = iterator_with_final_event(self._get_event_iterator())
         return self._event_iterator
 
     @abstractmethod
@@ -810,3 +853,16 @@ def _customize_output_object(transformer: type[JsonSchemaTransformer], o: Output
         json_schema=json_schema,
         strict=schema_transformer.is_strict_compatible if o.strict is None else o.strict,
     )
+
+
+def _get_final_result_event(e: ModelResponseStreamEvent, params: ModelRequestParameters) -> FinalResultEvent | None:
+    """Return an appropriate FinalResultEvent if `e` corresponds to a part that will produce a final result."""
+    if isinstance(e, PartStartEvent):
+        new_part = e.part
+        if isinstance(new_part, TextPart) and params.allow_text_output:  # pragma: no branch
+            return FinalResultEvent(tool_name=None, tool_call_id=None)
+        elif isinstance(new_part, ToolCallPart) and (tool_def := params.tool_defs.get(new_part.tool_name)):
+            if tool_def.kind == 'output':
+                return FinalResultEvent(tool_name=new_part.tool_name, tool_call_id=new_part.tool_call_id)
+            elif tool_def.kind == 'deferred':
+                return FinalResultEvent(tool_name=None, tool_call_id=None)

pydantic_ai/models/anthropic.py

@@ -21,7 +21,9 @@ from typing_extensions import assert_never
 from pydantic_ai.builtin_tools import CodeExecutionTool, WebSearchTool
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
+from .._run_context import RunContext
 from .._utils import guard_tool_call_id as _guard_tool_call_id
+from ..exceptions import UserError
 from ..messages import (
     BinaryContent,
     BuiltinToolCallPart,
@@ -196,13 +198,14 @@ class AnthropicModel(Model):
         messages: list[ModelMessage],
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
+        run_context: RunContext[Any] | None = None,
     ) -> AsyncIterator[StreamedResponse]:
         check_allow_model_requests()
         response = await self._messages_create(
             messages, True, cast(AnthropicModelSettings, model_settings or {}), model_request_parameters
         )
         async with response:
-            yield await self._process_streamed_response(response)
+            yield await self._process_streamed_response(response, model_request_parameters)
 
     @property
     def model_name(self) -> AnthropicModelName:
@@ -329,7 +332,9 @@ class AnthropicModel(Model):
 
         return ModelResponse(items, usage=_map_usage(response), model_name=response.model, vendor_id=response.id)
 
-    async def _process_streamed_response(self, response: AsyncStream[BetaRawMessageStreamEvent]) -> StreamedResponse:
+    async def _process_streamed_response(
+        self, response: AsyncStream[BetaRawMessageStreamEvent], model_request_parameters: ModelRequestParameters
+    ) -> StreamedResponse:
         peekable_response = _utils.PeekableAsyncStream(response)
         first_chunk = await peekable_response.peek()
         if isinstance(first_chunk, _utils.Unset):
@@ -338,14 +343,14 @@ class AnthropicModel(Model):
         # Since Anthropic doesn't provide a timestamp in the message, we'll use the current time
         timestamp = datetime.now(tz=timezone.utc)
         return AnthropicStreamedResponse(
-            _model_name=self._model_name, _response=peekable_response, _timestamp=timestamp
+            model_request_parameters=model_request_parameters,
+            _model_name=self._model_name,
+            _response=peekable_response,
+            _timestamp=timestamp,
         )
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[BetaToolParam]:
-        tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
-        if model_request_parameters.output_tools:
-            tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
-        return tools
+        return [self._map_tool_definition(r) for r in model_request_parameters.tool_defs.values()]
 
     def _get_builtin_tools(self, model_request_parameters: ModelRequestParameters) -> list[BetaToolUnionParam]:
         tools: list[BetaToolUnionParam] = []
@@ -363,6 +368,10 @@ class AnthropicModel(Model):
                 )
             elif isinstance(tool, CodeExecutionTool):  # pragma: no branch
                 tools.append(BetaCodeExecutionTool20250522Param(name='code_execution', type='code_execution_20250522'))
+            else:  # pragma: no cover
+                raise UserError(
+                    f'`{tool.__class__.__name__}` is not supported by `AnthropicModel`. If it should be, please file an issue.'
+                )
         return tools
 
     async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[BetaMessageParam]]:  # noqa: C901