pydantic-ai-slim 0.0.12__py3-none-any.whl → 0.0.13__py3-none-any.whl

pydantic_ai/messages.py

@@ -6,14 +6,13 @@ from typing import Annotated, Any, Literal, Union
 
 import pydantic
 import pydantic_core
-from pydantic import TypeAdapter
+from typing_extensions import Self
 
-from . import _pydantic
 from ._utils import now_utc as _now_utc
 
 
 @dataclass
-class SystemPrompt:
+class SystemPromptPart:
     """A system prompt, generally written by the application developer.
 
     This gives the model context and guidance on how to respond.
@@ -21,12 +20,13 @@ class SystemPrompt:
 
     content: str
     """The content of the prompt."""
-    role: Literal['system'] = 'system'
-    """Message type identifier, this type is available on all message as a discriminator."""
+
+    part_kind: Literal['system-prompt'] = 'system-prompt'
+    """Part type identifier, this is available on all parts as a discriminator."""
 
 
 @dataclass
-class UserPrompt:
+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],
@@ -35,29 +35,35 @@ class UserPrompt:
 
     content: str
     """The content of the prompt."""
+
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp of the prompt."""
-    role: Literal['user'] = 'user'
-    """Message type identifier, this type is available on all message as a discriminator."""
+
+    part_kind: Literal['user-prompt'] = 'user-prompt'
+    """Part type identifier, this is available on all parts as a discriminator."""
 
 
-tool_return_ta: TypeAdapter[Any] = TypeAdapter(Any)
+tool_return_ta: pydantic.TypeAdapter[Any] = pydantic.TypeAdapter(Any, config=pydantic.ConfigDict(defer_build=True))
 
 
 @dataclass
-class ToolReturn:
+class ToolReturnPart:
     """A tool return message, this encodes the result of running a tool."""
 
     tool_name: str
     """The name of the "tool" was called."""
+
     content: Any
     """The return value."""
-    tool_id: str | None = None
-    """Optional tool identifier, this is used by some models including OpenAI."""
+
+    tool_call_id: str | None = None
+    """Optional tool call identifier, this is used by some models including OpenAI."""
+
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp, when the tool returned."""
-    role: Literal['tool-return'] = 'tool-return'
-    """Message type identifier, this type is available on all message as a discriminator."""
+
+    part_kind: Literal['tool-return'] = 'tool-return'
+    """Part type identifier, this is available on all parts as a discriminator."""
 
     def model_response_str(self) -> str:
         if isinstance(self.content, str):
@@ -73,11 +79,11 @@ class ToolReturn:
             return {'return_value': tool_return_ta.dump_python(self.content, mode='json')}
 
 
-ErrorDetailsTa = _pydantic.LazyTypeAdapter(list[pydantic_core.ErrorDetails])
+error_details_ta = pydantic.TypeAdapter(list[pydantic_core.ErrorDetails], config=pydantic.ConfigDict(defer_build=True))
 
 
 @dataclass
-class RetryPrompt:
+class RetryPromptPart:
     """A message back to a model asking it to try again.
 
     This can be sent for a number of reasons:
@@ -98,37 +104,54 @@ class RetryPrompt:
     If the retry was triggered by a [`ValidationError`][pydantic_core.ValidationError], this will be a list of
     error details.
     """
+
     tool_name: str | None = None
     """The name of the tool that was called, if any."""
-    tool_id: str | None = None
-    """The tool identifier, if any."""
+
+    tool_call_id: str | None = None
+    """Optional tool call identifier, this is used by some models including OpenAI."""
+
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp, when the retry was triggered."""
-    role: Literal['retry-prompt'] = 'retry-prompt'
-    """Message type identifier, this type is available on all message as a discriminator."""
+
+    part_kind: Literal['retry-prompt'] = 'retry-prompt'
+    """Part type identifier, this is available on all parts as a discriminator."""
 
     def model_response(self) -> str:
         if isinstance(self.content, str):
             description = self.content
         else:
-            json_errors = ErrorDetailsTa.dump_json(self.content, exclude={'__all__': {'ctx'}}, indent=2)
+            json_errors = error_details_ta.dump_json(self.content, exclude={'__all__': {'ctx'}}, indent=2)
             description = f'{len(self.content)} validation errors: {json_errors.decode()}'
         return f'{description}\n\nFix the errors and try again.'
 
 
+ModelRequestPart = Annotated[
+    Union[SystemPromptPart, UserPromptPart, ToolReturnPart, RetryPromptPart], pydantic.Discriminator('part_kind')
+]
+"""A message part sent by PydanticAI to a model."""
+
+
 @dataclass
-class ModelTextResponse:
+class ModelRequest:
+    """A request generated by PydanticAI and sent to a model, e.g. a message from the PydanticAI app to the model."""
+
+    parts: list[ModelRequestPart]
+    """The parts of the user message."""
+
+    kind: Literal['request'] = 'request'
+    """Message type identifier, this is available on all parts as a discriminator."""
+
+
+@dataclass
+class TextPart:
     """A plain text response from a model."""
 
     content: str
     """The text content of the response."""
-    timestamp: datetime = field(default_factory=_now_utc)
-    """The timestamp of the response.
 
-    If the model provides a timestamp in the response (as OpenAI does) that will be used.
-    """
-    role: Literal['model-text-response'] = 'model-text-response'
-    """Message type identifier, this type is available on all message as a discriminator."""
+    part_kind: Literal['text'] = 'text'
+    """Part type identifier, this is available on all parts as a discriminator."""
 
 
 @dataclass
@@ -148,26 +171,31 @@ class ArgsDict:
 
 
 @dataclass
-class ToolCall:
-    """Either a tool call from the agent."""
+class ToolCallPart:
+    """A tool call from a model."""
 
     tool_name: str
     """The name of the tool to call."""
+
     args: ArgsJson | ArgsDict
     """The arguments to pass to the tool.
 
     Either as JSON or a Python dictionary depending on how data was returned.
     """
-    tool_id: str | None = None
-    """Optional tool identifier, this is used by some models including OpenAI."""
+
+    tool_call_id: str | None = None
+    """Optional tool call identifier, this is used by some models including OpenAI."""
+
+    part_kind: Literal['tool-call'] = 'tool-call'
+    """Part type identifier, this is available on all parts as a discriminator."""
 
     @classmethod
-    def from_json(cls, tool_name: str, args_json: str, tool_id: str | None = None) -> ToolCall:
-        return cls(tool_name, ArgsJson(args_json), tool_id)
+    def from_json(cls, tool_name: str, args_json: str, tool_call_id: str | None = None) -> Self:
+        return cls(tool_name, ArgsJson(args_json), tool_call_id)
 
     @classmethod
-    def from_dict(cls, tool_name: str, args_dict: dict[str, Any]) -> ToolCall:
-        return cls(tool_name, ArgsDict(args_dict))
+    def from_dict(cls, tool_name: str, args_dict: dict[str, Any], tool_call_id: str | None = None) -> Self:
+        return cls(tool_name, ArgsDict(args_dict), tool_call_id)
 
     def has_content(self) -> bool:
         if isinstance(self.args, ArgsDict):
@@ -176,28 +204,39 @@ class ToolCall:
             return bool(self.args.args_json)
 
 
+ModelResponsePart = Annotated[Union[TextPart, ToolCallPart], pydantic.Discriminator('part_kind')]
+"""A message part returned by a model."""
+
+
 @dataclass
-class ModelStructuredResponse:
-    """A structured response from a model.
+class ModelResponse:
+    """A response from a model, e.g. a message from the model to the PydanticAI app."""
 
-    This is used either to call a tool or to return a structured response from an agent run.
-    """
+    parts: list[ModelResponsePart]
+    """The parts of the model message."""
 
-    calls: list[ToolCall]
-    """The tool calls being made."""
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp of the response.
 
     If the model provides a timestamp in the response (as OpenAI does) that will be used.
     """
-    role: Literal['model-structured-response'] = 'model-structured-response'
-    """Message type identifier, this type is available on all message as a discriminator."""
+
+    kind: Literal['response'] = 'response'
+    """Message type identifier, this is available on all parts as a discriminator."""
+
+    @classmethod
+    def from_text(cls, content: str, timestamp: datetime | None = None) -> Self:
+        return cls([TextPart(content)], timestamp=timestamp or _now_utc())
+
+    @classmethod
+    def from_tool_call(cls, tool_call: ToolCallPart) -> Self:
+        return cls([tool_call])
 
 
-ModelAnyResponse = Union[ModelTextResponse, ModelStructuredResponse]
-"""Any response from a model."""
-Message = Union[SystemPrompt, UserPrompt, ToolReturn, RetryPrompt, ModelTextResponse, ModelStructuredResponse]
+ModelMessage = Union[ModelRequest, ModelResponse]
 """Any message send to or returned by a model."""
 
-MessagesTypeAdapter = _pydantic.LazyTypeAdapter(list[Annotated[Message, pydantic.Field(discriminator='role')]])
+ModelMessagesTypeAdapter = pydantic.TypeAdapter(
+    list[Annotated[ModelMessage, pydantic.Discriminator('kind')]], config=pydantic.ConfigDict(defer_build=True)
+)
 """Pydantic [`TypeAdapter`][pydantic.type_adapter.TypeAdapter] for (de)serializing messages."""

pydantic_ai/models/__init__.py

@@ -16,7 +16,8 @@ from typing import TYPE_CHECKING, Literal, Union
 import httpx
 
 from ..exceptions import UserError
-from ..messages import Message, ModelAnyResponse, ModelStructuredResponse
+from ..messages import ModelMessage, ModelResponse
+from ..settings import ModelSettings
 
 if TYPE_CHECKING:
     from ..result import Cost
@@ -31,6 +32,7 @@ KnownModelName = Literal[
     'openai:o1-preview',
     'openai:o1-mini',
     'openai:gpt-3.5-turbo',
+    'groq:llama-3.3-70b-versatile',
     'groq:llama-3.1-70b-versatile',
     'groq:llama3-groq-70b-8192-tool-use-preview',
     'groq:llama3-groq-8b-8192-tool-use-preview',
@@ -47,8 +49,15 @@ KnownModelName = Literal[
     'groq:gemma-7b-it',
     'gemini-1.5-flash',
     'gemini-1.5-pro',
+    'gemini-2.0-flash-exp',
     'vertexai:gemini-1.5-flash',
     'vertexai:gemini-1.5-pro',
+    # since mistral models are supported by other providers (e.g. ollama), and some of their models (e.g. "codestral")
+    # don't start with "mistral", we add the "mistral:" prefix to all to be explicit
+    'mistral:mistral-small-latest',
+    'mistral:mistral-large-latest',
+    'mistral:codestral-latest',
+    'mistral:mistral-moderation-latest',
     'ollama:codellama',
     'ollama:gemma',
     'ollama:gemma2',
@@ -66,6 +75,9 @@ KnownModelName = Literal[
     'ollama:qwen2',
     'ollama:qwen2.5',
     'ollama:starcoder2',
+    'claude-3-5-haiku-latest',
+    'claude-3-5-sonnet-latest',
+    'claude-3-opus-latest',
     'test',
 ]
 """Known model names that can be used with the `model` parameter of [`Agent`][pydantic_ai.Agent].
@@ -108,12 +120,16 @@ class AgentModel(ABC):
     """Model configured for each step of an Agent run."""
 
     @abstractmethod
-    async def request(self, messages: list[Message]) -> tuple[ModelAnyResponse, Cost]:
+    async def request(
+        self, messages: list[ModelMessage], model_settings: ModelSettings | None
+    ) -> tuple[ModelResponse, Cost]:
         """Make a request to the model."""
         raise NotImplementedError()
 
     @asynccontextmanager
-    async def request_stream(self, messages: list[Message]) -> AsyncIterator[EitherStreamedResponse]:
+    async def request_stream(
+        self, messages: list[ModelMessage], model_settings: ModelSettings | None
+    ) -> AsyncIterator[EitherStreamedResponse]:
         """Make a request to the model and return a streaming response."""
         raise NotImplementedError(f'Streamed requests not supported by this {self.__class__.__name__}')
         # yield is required to make this a generator for type checking
@@ -178,10 +194,10 @@ class StreamStructuredResponse(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    def get(self, *, final: bool = False) -> ModelStructuredResponse:
-        """Get the `ModelStructuredResponse` at this point.
+    def get(self, *, final: bool = False) -> ModelResponse:
+        """Get the `ModelResponse` at this point.
 
-        The `ModelStructuredResponse` may or may not be complete, depending on whether the stream is finished.
+        The `ModelResponse` may or may not be complete, depending on whether the stream is finished.
 
         Args:
             final: If True, this is the final call, after iteration is complete, the response should be fully validated.
@@ -270,10 +286,18 @@ def infer_model(model: Model | KnownModelName) -> Model:
         from .vertexai import VertexAIModel
 
         return VertexAIModel(model[9:])  # pyright: ignore[reportArgumentType]
+    elif model.startswith('mistral:'):
+        from .mistral import MistralModel
+
+        return MistralModel(model[8:])
     elif model.startswith('ollama:'):
         from .ollama import OllamaModel
 
         return OllamaModel(model[7:])
+    elif model.startswith('claude'):
+        from .anthropic import AnthropicModel
+
+        return AnthropicModel(model)
     else:
         raise UserError(f'Unknown model: {model}')
 

pydantic_ai/models/anthropic.py

@@ -0,0 +1,344 @@
+from __future__ import annotations as _annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from typing import Any, Literal, Union, cast, overload
+
+from httpx import AsyncClient as AsyncHTTPClient
+from typing_extensions import assert_never
+
+from .. import result
+from .._utils import guard_tool_call_id as _guard_tool_call_id
+from ..messages import (
+    ArgsDict,
+    ModelMessage,
+    ModelRequest,
+    ModelResponse,
+    ModelResponsePart,
+    RetryPromptPart,
+    SystemPromptPart,
+    TextPart,
+    ToolCallPart,
+    ToolReturnPart,
+    UserPromptPart,
+)
+from ..settings import ModelSettings
+from ..tools import ToolDefinition
+from . import (
+    AgentModel,
+    EitherStreamedResponse,
+    Model,
+    cached_async_http_client,
+    check_allow_model_requests,
+)
+
+try:
+    from anthropic import NOT_GIVEN, AsyncAnthropic, AsyncStream
+    from anthropic.types import (
+        Message as AnthropicMessage,
+        MessageParam,
+        RawMessageDeltaEvent,
+        RawMessageStartEvent,
+        RawMessageStreamEvent,
+        TextBlock,
+        TextBlockParam,
+        ToolChoiceParam,
+        ToolParam,
+        ToolResultBlockParam,
+        ToolUseBlock,
+        ToolUseBlockParam,
+    )
+except ImportError as _import_error:
+    raise ImportError(
+        'Please install `anthropic` to use the Anthropic model, '
+        "you can use the `anthropic` optional group — `pip install 'pydantic-ai-slim[anthropic]'`"
+    ) from _import_error
+
+LatestAnthropicModelNames = Literal[
+    'claude-3-5-haiku-latest',
+    'claude-3-5-sonnet-latest',
+    'claude-3-opus-latest',
+]
+"""Latest named Anthropic models."""
+
+AnthropicModelName = Union[str, LatestAnthropicModelNames]
+"""Possible Anthropic model names.
+
+Since Anthropic supports a variety of date-stamped models, we explicitly list the latest models but
+allow any name in the type hints.
+Since [the Anthropic docs](https://docs.anthropic.com/en/docs/about-claude/models) for a full list.
+"""
+
+
+@dataclass(init=False)
+class AnthropicModel(Model):
+    """A model that uses the Anthropic API.
+
+    Internally, this uses the [Anthropic Python client](https://github.com/anthropics/anthropic-sdk-python) to interact with the API.
+
+    Apart from `__init__`, all methods are private or match those of the base class.
+
+    !!! note
+        The `AnthropicModel` class does not yet support streaming responses.
+        We anticipate adding support for streaming responses in a near-term future release.
+    """
+
+    model_name: AnthropicModelName
+    client: AsyncAnthropic = field(repr=False)
+
+    def __init__(
+        self,
+        model_name: AnthropicModelName,
+        *,
+        api_key: str | None = None,
+        anthropic_client: AsyncAnthropic | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ):
+        """Initialize an Anthropic model.
+
+        Args:
+            model_name: The name of the Anthropic model to use. List of model names available
+                [here](https://docs.anthropic.com/en/docs/about-claude/models).
+            api_key: The API key to use for authentication, if not provided, the `ANTHROPIC_API_KEY` environment variable
+                will be used if available.
+            anthropic_client: An existing
+                [`AsyncAnthropic`](https://github.com/anthropics/anthropic-sdk-python?tab=readme-ov-file#async-usage)
+                client to use, if provided, `api_key` and `http_client` must be `None`.
+            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
+        """
+        self.model_name = model_name
+        if anthropic_client is not None:
+            assert http_client is None, 'Cannot provide both `anthropic_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `anthropic_client` and `api_key`'
+            self.client = anthropic_client
+        elif http_client is not None:
+            self.client = AsyncAnthropic(api_key=api_key, http_client=http_client)
+        else:
+            self.client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())
+
+    async def agent_model(
+        self,
+        *,
+        function_tools: list[ToolDefinition],
+        allow_text_result: bool,
+        result_tools: list[ToolDefinition],
+    ) -> AgentModel:
+        check_allow_model_requests()
+        tools = [self._map_tool_definition(r) for r in function_tools]
+        if result_tools:
+            tools += [self._map_tool_definition(r) for r in result_tools]
+        return AnthropicAgentModel(
+            self.client,
+            self.model_name,
+            allow_text_result,
+            tools,
+        )
+
+    def name(self) -> str:
+        return self.model_name
+
+    @staticmethod
+    def _map_tool_definition(f: ToolDefinition) -> ToolParam:
+        return {
+            'name': f.name,
+            'description': f.description,
+            'input_schema': f.parameters_json_schema,
+        }
+
+
+@dataclass
+class AnthropicAgentModel(AgentModel):
+    """Implementation of `AgentModel` for Anthropic models."""
+
+    client: AsyncAnthropic
+    model_name: str
+    allow_text_result: bool
+    tools: list[ToolParam]
+
+    async def request(
+        self, messages: list[ModelMessage], model_settings: ModelSettings | None
+    ) -> tuple[ModelResponse, result.Cost]:
+        response = await self._messages_create(messages, False, model_settings)
+        return self._process_response(response), _map_cost(response)
+
+    @asynccontextmanager
+    async def request_stream(
+        self, messages: list[ModelMessage], model_settings: ModelSettings | None
+    ) -> AsyncIterator[EitherStreamedResponse]:
+        response = await self._messages_create(messages, True, model_settings)
+        async with response:
+            yield await self._process_streamed_response(response)
+
+    @overload
+    async def _messages_create(
+        self, messages: list[ModelMessage], stream: Literal[True], model_settings: ModelSettings | None
+    ) -> AsyncStream[RawMessageStreamEvent]:
+        pass
+
+    @overload
+    async def _messages_create(
+        self, messages: list[ModelMessage], stream: Literal[False], model_settings: ModelSettings | None
+    ) -> AnthropicMessage:
+        pass
+
+    async def _messages_create(
+        self, messages: list[ModelMessage], stream: bool, model_settings: ModelSettings | None
+    ) -> AnthropicMessage | AsyncStream[RawMessageStreamEvent]:
+        # standalone function to make it easier to override
+        if not self.tools:
+            tool_choice: ToolChoiceParam | None = None
+        elif not self.allow_text_result:
+            tool_choice = {'type': 'any'}
+        else:
+            tool_choice = {'type': 'auto'}
+
+        system_prompt, anthropic_messages = self._map_message(messages)
+
+        model_settings = model_settings or {}
+
+        return await self.client.messages.create(
+            max_tokens=model_settings.get('max_tokens', 1024),
+            system=system_prompt or NOT_GIVEN,
+            messages=anthropic_messages,
+            model=self.model_name,
+            tools=self.tools or NOT_GIVEN,
+            tool_choice=tool_choice or NOT_GIVEN,
+            stream=stream,
+            temperature=model_settings.get('temperature', NOT_GIVEN),
+            top_p=model_settings.get('top_p', NOT_GIVEN),
+            timeout=model_settings.get('timeout', NOT_GIVEN),
+        )
+
+    @staticmethod
+    def _process_response(response: AnthropicMessage) -> ModelResponse:
+        """Process a non-streamed response, and prepare a message to return."""
+        items: list[ModelResponsePart] = []
+        for item in response.content:
+            if isinstance(item, TextBlock):
+                items.append(TextPart(item.text))
+            else:
+                assert isinstance(item, ToolUseBlock), 'unexpected item type'
+                items.append(
+                    ToolCallPart.from_dict(
+                        item.name,
+                        cast(dict[str, Any], item.input),
+                        item.id,
+                    )
+                )
+
+        return ModelResponse(items)
+
+    @staticmethod
+    async def _process_streamed_response(response: AsyncStream[RawMessageStreamEvent]) -> EitherStreamedResponse:
+        """TODO: Process a streamed response, and prepare a streaming response to return."""
+        # We don't yet support streamed responses from Anthropic, so we raise an error here for now.
+        # Streamed responses will be supported in a future release.
+
+        raise RuntimeError('Streamed responses are not yet supported for Anthropic models.')
+
+        # Should be returning some sort of AnthropicStreamTextResponse or AnthropicStreamStructuredResponse
+        # depending on the type of chunk we get, but we need to establish how we handle (and when we get) the following:
+        # RawMessageStartEvent
+        # RawMessageDeltaEvent
+        # RawMessageStopEvent
+        # RawContentBlockStartEvent
+        # RawContentBlockDeltaEvent
+        # RawContentBlockDeltaEvent
+        #
+        # We might refactor streaming internally before we implement this...
+
+    @staticmethod
+    def _map_message(messages: list[ModelMessage]) -> tuple[str, list[MessageParam]]:
+        """Just maps a `pydantic_ai.Message` to a `anthropic.types.MessageParam`."""
+        system_prompt: str = ''
+        anthropic_messages: list[MessageParam] = []
+        for m in messages:
+            if isinstance(m, ModelRequest):
+                for part in m.parts:
+                    if isinstance(part, SystemPromptPart):
+                        system_prompt += part.content
+                    elif isinstance(part, UserPromptPart):
+                        anthropic_messages.append(MessageParam(role='user', content=part.content))
+                    elif isinstance(part, ToolReturnPart):
+                        anthropic_messages.append(
+                            MessageParam(
+                                role='user',
+                                content=[
+                                    ToolResultBlockParam(
+                                        tool_use_id=_guard_tool_call_id(t=part, model_source='Anthropic'),
+                                        type='tool_result',
+                                        content=part.model_response_str(),
+                                        is_error=False,
+                                    )
+                                ],
+                            )
+                        )
+                    elif isinstance(part, RetryPromptPart):
+                        if part.tool_name is None:
+                            anthropic_messages.append(MessageParam(role='user', content=part.model_response()))
+                        else:
+                            anthropic_messages.append(
+                                MessageParam(
+                                    role='user',
+                                    content=[
+                                        ToolUseBlockParam(
+                                            id=_guard_tool_call_id(t=part, model_source='Anthropic'),
+                                            input=part.model_response(),
+                                            name=part.tool_name,
+                                            type='tool_use',
+                                        ),
+                                    ],
+                                )
+                            )
+            elif isinstance(m, ModelResponse):
+                content: list[TextBlockParam | ToolUseBlockParam] = []
+                for item in m.parts:
+                    if isinstance(item, TextPart):
+                        content.append(TextBlockParam(text=item.content, type='text'))
+                    else:
+                        assert isinstance(item, ToolCallPart)
+                        content.append(_map_tool_call(item))
+                anthropic_messages.append(MessageParam(role='assistant', content=content))
+            else:
+                assert_never(m)
+        return system_prompt, anthropic_messages
+
+
+def _map_tool_call(t: ToolCallPart) -> ToolUseBlockParam:
+    assert isinstance(t.args, ArgsDict), f'Expected ArgsDict, got {t.args}'
+    return ToolUseBlockParam(
+        id=_guard_tool_call_id(t=t, model_source='Anthropic'),
+        type='tool_use',
+        name=t.tool_name,
+        input=t.args.args_dict,
+    )
+
+
+def _map_cost(message: AnthropicMessage | RawMessageStreamEvent) -> result.Cost:
+    if isinstance(message, AnthropicMessage):
+        usage = message.usage
+    else:
+        if isinstance(message, RawMessageStartEvent):
+            usage = message.message.usage
+        elif isinstance(message, RawMessageDeltaEvent):
+            usage = message.usage
+        else:
+            # No usage information provided in:
+            # - RawMessageStopEvent
+            # - RawContentBlockStartEvent
+            # - RawContentBlockDeltaEvent
+            # - RawContentBlockStopEvent
+            usage = None
+
+    if usage is None:
+        return result.Cost()
+
+    request_tokens = getattr(usage, 'input_tokens', None)
+
+    return result.Cost(
+        # Usage coming from the RawMessageDeltaEvent doesn't have input token data, hence this getattr
+        request_tokens=request_tokens,
+        response_tokens=usage.output_tokens,
+        total_tokens=(request_tokens or 0) + usage.output_tokens,
+    )