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

pydantic_ai/messages.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-import json
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Annotated, Any, Literal, Union
@@ -74,6 +73,9 @@ class ToolReturn:
             return {'return_value': tool_return_ta.dump_python(self.content, mode='json')}
 
 
+ErrorDetailsTa = _pydantic.LazyTypeAdapter(list[pydantic_core.ErrorDetails])
+
+
 @dataclass
 class RetryPrompt:
     """A message back to a model asking it to try again.
@@ -109,7 +111,8 @@ class RetryPrompt:
         if isinstance(self.content, str):
             description = self.content
         else:
-            description = f'{len(self.content)} validation errors: {json.dumps(self.content, indent=2)}'
+            json_errors = ErrorDetailsTa.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.'
 
 

pydantic_ai/models/__init__.py

@@ -7,11 +7,11 @@ specific LLM being used.
 from __future__ import annotations as _annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Iterable, Iterator, Mapping, Sequence
+from collections.abc import AsyncIterator, Iterable, Iterator
 from contextlib import asynccontextmanager, contextmanager
 from datetime import datetime
 from functools import cache
-from typing import TYPE_CHECKING, Literal, Protocol, Union
+from typing import TYPE_CHECKING, Literal, Union
 
 import httpx
 
@@ -19,8 +19,8 @@ from ..exceptions import UserError
 from ..messages import Message, ModelAnyResponse, ModelStructuredResponse
 
 if TYPE_CHECKING:
-    from .._utils import ObjectJsonSchema
     from ..result import Cost
+    from ..tools import ToolDefinition
 
 
 KnownModelName = Literal[
@@ -49,6 +49,23 @@ KnownModelName = Literal[
     'gemini-1.5-pro',
     'vertexai:gemini-1.5-flash',
     'vertexai:gemini-1.5-pro',
+    'ollama:codellama',
+    'ollama:gemma',
+    'ollama:gemma2',
+    'ollama:llama3',
+    'ollama:llama3.1',
+    'ollama:llama3.2',
+    'ollama:llama3.2-vision',
+    'ollama:llama3.3',
+    'ollama:mistral',
+    'ollama:mistral-nemo',
+    'ollama:mixtral',
+    'ollama:phi3',
+    'ollama:qwq',
+    'ollama:qwen',
+    'ollama:qwen2',
+    'ollama:qwen2.5',
+    'ollama:starcoder2',
     'test',
 ]
 """Known model names that can be used with the `model` parameter of [`Agent`][pydantic_ai.Agent].
@@ -63,11 +80,12 @@ class Model(ABC):
     @abstractmethod
     async def agent_model(
         self,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        *,
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ) -> AgentModel:
-        """Create an agent model.
+        """Create an agent model, this is called for each step of an agent run.
 
         This is async in case slow/async config checks need to be performed that can't be done in `__init__`.
 
@@ -87,7 +105,7 @@ class Model(ABC):
 
 
 class AgentModel(ABC):
-    """Model configured for a specific agent."""
+    """Model configured for each step of an Agent run."""
 
     @abstractmethod
     async def request(self, messages: list[Message]) -> tuple[ModelAnyResponse, Cost]:
@@ -238,7 +256,7 @@ def infer_model(model: Model | KnownModelName) -> Model:
     elif model.startswith('openai:'):
         from .openai import OpenAIModel
 
-        return OpenAIModel(model[7:])  # pyright: ignore[reportArgumentType]
+        return OpenAIModel(model[7:])
     elif model.startswith('gemini'):
         from .gemini import GeminiModel
 
@@ -252,39 +270,14 @@ def infer_model(model: Model | KnownModelName) -> Model:
         from .vertexai import VertexAIModel
 
         return VertexAIModel(model[9:])  # pyright: ignore[reportArgumentType]
+    elif model.startswith('ollama:'):
+        from .ollama import OllamaModel
+
+        return OllamaModel(model[7:])
     else:
         raise UserError(f'Unknown model: {model}')
 
 
-class AbstractToolDefinition(Protocol):
-    """Abstract definition of a function/tool.
-
-    This is used for both function tools and result tools.
-    """
-
-    @property
-    def name(self) -> str:
-        """The name of the tool."""
-        ...
-
-    @property
-    def description(self) -> str:
-        """The description of the tool."""
-        ...
-
-    @property
-    def json_schema(self) -> ObjectJsonSchema:
-        """The JSON schema for the tool's arguments."""
-        ...
-
-    @property
-    def outer_typed_dict_key(self) -> str | None:
-        """The key in the outer [TypedDict] that wraps a result tool.
-
-        This will only be set for result tools which don't have an `object` JSON schema.
-        """
-
-
 @cache
 def cached_async_http_client(timeout: int = 600, connect: int = 5) -> httpx.AsyncClient:
     """Cached HTTPX async client so multiple agents and calls can share the same client.

pydantic_ai/models/function.py

@@ -2,7 +2,7 @@ from __future__ import annotations as _annotations
 
 import inspect
 import re
-from collections.abc import AsyncIterator, Awaitable, Iterable, Mapping, Sequence
+from collections.abc import AsyncIterator, Awaitable, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -14,14 +14,8 @@ from typing_extensions import TypeAlias, assert_never, overload
 
 from .. import _utils, result
 from ..messages import ArgsJson, Message, ModelAnyResponse, ModelStructuredResponse, ToolCall
-from . import (
-    AbstractToolDefinition,
-    AgentModel,
-    EitherStreamedResponse,
-    Model,
-    StreamStructuredResponse,
-    StreamTextResponse,
-)
+from ..tools import ToolDefinition
+from . import AgentModel, EitherStreamedResponse, Model, StreamStructuredResponse, StreamTextResponse
 
 
 @dataclass(init=False)
@@ -59,11 +53,11 @@ class FunctionModel(Model):
 
     async def agent_model(
         self,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        *,
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ) -> AgentModel:
-        result_tools = list(result_tools) if result_tools is not None else None
         return FunctionAgentModel(
             self.function, self.stream_function, AgentInfo(function_tools, allow_text_result, result_tools)
         )
@@ -84,7 +78,7 @@ class AgentInfo:
     This is passed as the second to functions used within [`FunctionModel`][pydantic_ai.models.function.FunctionModel].
     """
 
-    function_tools: Mapping[str, AbstractToolDefinition]
+    function_tools: list[ToolDefinition]
     """The function tools available on this agent.
 
     These are the tools registered via the [`tool`][pydantic_ai.Agent.tool] and
@@ -92,7 +86,7 @@ class AgentInfo:
     """
     allow_text_result: bool
     """Whether a plain text result is allowed."""
-    result_tools: list[AbstractToolDefinition] | None
+    result_tools: list[ToolDefinition]
     """The tools that can called as the final result of the run."""
 
 

pydantic_ai/models/gemini.py

@@ -2,7 +2,7 @@ from __future__ import annotations as _annotations
 
 import os
 import re
-from collections.abc import AsyncIterator, Iterable, Mapping, Sequence
+from collections.abc import AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from copy import deepcopy
 from dataclasses import dataclass, field
@@ -25,8 +25,8 @@ from ..messages import (
     ToolCall,
     ToolReturn,
 )
+from ..tools import ToolDefinition
 from . import (
-    AbstractToolDefinition,
     AgentModel,
     EitherStreamedResponse,
     Model,
@@ -90,9 +90,10 @@ class GeminiModel(Model):
 
     async def agent_model(
         self,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        *,
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ) -> GeminiAgentModel:
         return GeminiAgentModel(
             http_client=self.http_client,
@@ -142,13 +143,13 @@ class GeminiAgentModel(AgentModel):
         model_name: GeminiModelName,
         auth: AuthProtocol,
         url: str,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ):
         check_allow_model_requests()
-        tools = [_function_from_abstract_tool(t) for t in function_tools.values()]
-        if result_tools is not None:
+        tools = [_function_from_abstract_tool(t) for t in function_tools]
+        if result_tools:
             tools += [_function_from_abstract_tool(t) for t in result_tools]
 
         if allow_text_result:
@@ -504,8 +505,8 @@ class _GeminiFunction(TypedDict):
     """
 
 
-def _function_from_abstract_tool(tool: AbstractToolDefinition) -> _GeminiFunction:
-    json_schema = _GeminiJsonSchema(tool.json_schema).simplify()
+def _function_from_abstract_tool(tool: ToolDefinition) -> _GeminiFunction:
+    json_schema = _GeminiJsonSchema(tool.parameters_json_schema).simplify()
     f = _GeminiFunction(
         name=tool.name,
         description=tool.description,

pydantic_ai/models/groq.py

@@ -1,6 +1,6 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import AsyncIterator, Iterable, Mapping, Sequence
+from collections.abc import AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
@@ -21,8 +21,8 @@ from ..messages import (
     ToolReturn,
 )
 from ..result import Cost
+from ..tools import ToolDefinition
 from . import (
-    AbstractToolDefinition,
     AgentModel,
     EitherStreamedResponse,
     Model,
@@ -37,11 +37,11 @@ try:
     from groq.types import chat
     from groq.types.chat import ChatCompletion, ChatCompletionChunk
     from groq.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
-except ImportError as e:
+except ImportError as _import_error:
     raise ImportError(
         'Please install `groq` to use the Groq model, '
         "you can use the `groq` optional group — `pip install 'pydantic-ai[groq]'`"
-    ) from e
+    ) from _import_error
 
 GroqModelName = Literal[
     'llama-3.1-70b-versatile',
@@ -109,13 +109,14 @@ class GroqModel(Model):
 
     async def agent_model(
         self,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        *,
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ) -> AgentModel:
         check_allow_model_requests()
-        tools = [self._map_tool_definition(r) for r in function_tools.values()]
-        if result_tools is not None:
+        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 GroqAgentModel(
             self.client,
@@ -128,13 +129,13 @@ class GroqModel(Model):
         return f'groq:{self.model_name}'
 
     @staticmethod
-    def _map_tool_definition(f: AbstractToolDefinition) -> chat.ChatCompletionToolParam:
+    def _map_tool_definition(f: ToolDefinition) -> chat.ChatCompletionToolParam:
         return {
             'type': 'function',
             'function': {
                 'name': f.name,
                 'description': f.description,
-                'parameters': f.json_schema,
+                'parameters': f.parameters_json_schema,
             },
         }
 
@@ -208,33 +209,29 @@ class GroqAgentModel(AgentModel):
     @staticmethod
     async def _process_streamed_response(response: AsyncStream[ChatCompletionChunk]) -> EitherStreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
-        try:
-            first_chunk = await response.__anext__()
-        except StopAsyncIteration as e:  # pragma: no cover
-            raise UnexpectedModelBehavior('Streamed response ended without content or tool calls') from e
-        timestamp = datetime.fromtimestamp(first_chunk.created, tz=timezone.utc)
-        delta = first_chunk.choices[0].delta
-        start_cost = _map_cost(first_chunk)
-
-        # the first chunk may only contain `role`, so we iterate until we get either `tool_calls` or `content`
-        while delta.tool_calls is None and delta.content is None:
+        timestamp: datetime | None = None
+        start_cost = Cost()
+        # the first chunk may contain enough information so we iterate until we get either `tool_calls` or `content`
+        while True:
             try:
-                next_chunk = await response.__anext__()
+                chunk = await response.__anext__()
             except StopAsyncIteration as e:
                 raise UnexpectedModelBehavior('Streamed response ended without content or tool calls') from e
-            delta = next_chunk.choices[0].delta
-            start_cost += _map_cost(next_chunk)
-
-        if delta.content is not None:
-            return GroqStreamTextResponse(delta.content, response, timestamp, start_cost)
-        else:
-            assert delta.tool_calls is not None, f'Expected delta with tool_calls, got {delta}'
-            return GroqStreamStructuredResponse(
-                response,
-                {c.index: c for c in delta.tool_calls},
-                timestamp,
-                start_cost,
-            )
+            timestamp = timestamp or datetime.fromtimestamp(chunk.created, tz=timezone.utc)
+            start_cost += _map_cost(chunk)
+
+            if chunk.choices:
+                delta = chunk.choices[0].delta
+
+                if delta.content is not None:
+                    return GroqStreamTextResponse(delta.content, response, timestamp, start_cost)
+                elif delta.tool_calls is not None:
+                    return GroqStreamStructuredResponse(
+                        response,
+                        {c.index: c for c in delta.tool_calls},
+                        timestamp,
+                        start_cost,
+                    )
 
     @staticmethod
     def _map_message(message: Message) -> chat.ChatCompletionMessageParam:

pydantic_ai/models/ollama.py

@@ -0,0 +1,116 @@
+from __future__ import annotations as _annotations
+
+from dataclasses import dataclass
+from typing import Literal, Union
+
+from httpx import AsyncClient as AsyncHTTPClient
+
+from ..tools import ToolDefinition
+from . import (
+    AgentModel,
+    Model,
+    cached_async_http_client,
+)
+
+try:
+    from openai import AsyncOpenAI
+except ImportError as e:
+    raise ImportError(
+        'Please install `openai` to use the OpenAI model, '
+        "you can use the `openai` optional group — `pip install 'pydantic-ai[openai]'`"
+    ) from e
+
+
+from .openai import OpenAIModel
+
+CommonOllamaModelNames = Literal[
+    'codellama',
+    'gemma',
+    'gemma2',
+    'llama3',
+    'llama3.1',
+    'llama3.2',
+    'llama3.2-vision',
+    'llama3.3',
+    'mistral',
+    'mistral-nemo',
+    'mixtral',
+    'phi3',
+    'qwq',
+    'qwen',
+    'qwen2',
+    'qwen2.5',
+    'starcoder2',
+]
+"""This contains just the most common ollama models.
+
+For a full list see [ollama.com/library](https://ollama.com/library).
+"""
+OllamaModelName = Union[CommonOllamaModelNames, str]
+"""Possible ollama models.
+
+Since Ollama supports hundreds of models, we explicitly list the most models but
+allow any name in the type hints.
+"""
+
+
+@dataclass(init=False)
+class OllamaModel(Model):
+    """A model that implements Ollama using the OpenAI API.
+
+    Internally, this uses the [OpenAI Python client](https://github.com/openai/openai-python) to interact with the Ollama server.
+
+    Apart from `__init__`, all methods are private or match those of the base class.
+    """
+
+    model_name: OllamaModelName
+    openai_model: OpenAIModel
+
+    def __init__(
+        self,
+        model_name: OllamaModelName,
+        *,
+        base_url: str | None = 'http://localhost:11434/v1/',
+        openai_client: AsyncOpenAI | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ):
+        """Initialize an Ollama model.
+
+        Ollama has built-in compatability for the OpenAI chat completions API ([source](https://ollama.com/blog/openai-compatibility)), so we reuse the
+        [`OpenAIModel`][pydantic_ai.models.openai.OpenAIModel] here.
+
+        Args:
+            model_name: The name of the Ollama model to use. List of models available [here](https://ollama.com/library)
+                You must first download the model (`ollama pull <MODEL-NAME>`) in order to use the model
+            base_url: The base url for the ollama requests. The default value is the ollama default
+            openai_client: An existing
+                [`AsyncOpenAI`](https://github.com/openai/openai-python?tab=readme-ov-file#async-usage)
+                client to use, if provided, `base_url` and `http_client` must be `None`.
+            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
+        """
+        self.model_name = model_name
+        if openai_client is not None:
+            assert base_url is None, 'Cannot provide both `openai_client` and `base_url`'
+            assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
+            self.openai_model = OpenAIModel(model_name=model_name, openai_client=openai_client)
+        else:
+            # API key is not required for ollama but a value is required to create the client
+            http_client_ = http_client or cached_async_http_client()
+            oai_client = AsyncOpenAI(base_url=base_url, api_key='ollama', http_client=http_client_)
+            self.openai_model = OpenAIModel(model_name=model_name, openai_client=oai_client)
+
+    async def agent_model(
+        self,
+        *,
+        function_tools: list[ToolDefinition],
+        allow_text_result: bool,
+        result_tools: list[ToolDefinition],
+    ) -> AgentModel:
+        return await self.openai_model.agent_model(
+            function_tools=function_tools,
+            allow_text_result=allow_text_result,
+            result_tools=result_tools,
+        )
+
+    def name(self) -> str:
+        return f'ollama:{self.model_name}'

pydantic_ai/models/openai.py

@@ -1,10 +1,10 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import AsyncIterator, Iterable, Mapping, Sequence
+from collections.abc import AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Literal, overload
+from typing import Literal, Union, overload
 
 from httpx import AsyncClient as AsyncHTTPClient
 from typing_extensions import assert_never
@@ -21,8 +21,8 @@ from ..messages import (
     ToolReturn,
 )
 from ..result import Cost
+from ..tools import ToolDefinition
 from . import (
-    AbstractToolDefinition,
     AgentModel,
     EitherStreamedResponse,
     Model,
@@ -37,11 +37,17 @@ try:
     from openai.types import ChatModel, chat
     from openai.types.chat import ChatCompletionChunk
     from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
-except ImportError as e:
+except ImportError as _import_error:
     raise ImportError(
         'Please install `openai` to use the OpenAI model, '
         "you can use the `openai` optional group — `pip install 'pydantic-ai[openai]'`"
-    ) from e
+    ) from _import_error
+
+OpenAIModelName = Union[ChatModel, str]
+"""
+Using this more broad type for the model name instead of the ChatModel definition
+allows this model to be used more easily with other model types (ie, Ollama)
+"""
 
 
 @dataclass(init=False)
@@ -53,12 +59,12 @@ class OpenAIModel(Model):
     Apart from `__init__`, all methods are private or match those of the base class.
     """
 
-    model_name: ChatModel
+    model_name: OpenAIModelName
     client: AsyncOpenAI = field(repr=False)
 
     def __init__(
         self,
-        model_name: ChatModel,
+        model_name: OpenAIModelName,
         *,
         api_key: str | None = None,
         openai_client: AsyncOpenAI | None = None,
@@ -77,7 +83,7 @@ class OpenAIModel(Model):
                 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: ChatModel = model_name
+        self.model_name: OpenAIModelName = model_name
         if openai_client is not None:
             assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
@@ -89,13 +95,14 @@ class OpenAIModel(Model):
 
     async def agent_model(
         self,
-        function_tools: Mapping[str, AbstractToolDefinition],
+        *,
+        function_tools: list[ToolDefinition],
         allow_text_result: bool,
-        result_tools: Sequence[AbstractToolDefinition] | None,
+        result_tools: list[ToolDefinition],
     ) -> AgentModel:
         check_allow_model_requests()
-        tools = [self._map_tool_definition(r) for r in function_tools.values()]
-        if result_tools is not None:
+        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 OpenAIAgentModel(
             self.client,
@@ -108,13 +115,13 @@ class OpenAIModel(Model):
         return f'openai:{self.model_name}'
 
     @staticmethod
-    def _map_tool_definition(f: AbstractToolDefinition) -> chat.ChatCompletionToolParam:
+    def _map_tool_definition(f: ToolDefinition) -> chat.ChatCompletionToolParam:
         return {
             'type': 'function',
             'function': {
                 'name': f.name,
                 'description': f.description,
-                'parameters': f.json_schema,
+                'parameters': f.parameters_json_schema,
             },
         }
 
@@ -124,7 +131,7 @@ class OpenAIAgentModel(AgentModel):
     """Implementation of `AgentModel` for OpenAI models."""
 
     client: AsyncOpenAI
-    model_name: ChatModel
+    model_name: OpenAIModelName
     allow_text_result: bool
     tools: list[chat.ChatCompletionToolParam]
 
@@ -188,33 +195,31 @@ class OpenAIAgentModel(AgentModel):
     @staticmethod
     async def _process_streamed_response(response: AsyncStream[ChatCompletionChunk]) -> EitherStreamedResponse:
         """Process a streamed response, and prepare a streaming response to return."""
-        try:
-            first_chunk = await response.__anext__()
-        except StopAsyncIteration as e:  # pragma: no cover
-            raise UnexpectedModelBehavior('Streamed response ended without content or tool calls') from e
-        timestamp = datetime.fromtimestamp(first_chunk.created, tz=timezone.utc)
-        delta = first_chunk.choices[0].delta
-        start_cost = _map_cost(first_chunk)
-
-        # the first chunk may only contain `role`, so we iterate until we get either `tool_calls` or `content`
-        while delta.tool_calls is None and delta.content is None:
+        timestamp: datetime | None = None
+        start_cost = Cost()
+        # the first chunk may contain enough information so we iterate until we get either `tool_calls` or `content`
+        while True:
             try:
-                next_chunk = await response.__anext__()
+                chunk = await response.__anext__()
             except StopAsyncIteration as e:
                 raise UnexpectedModelBehavior('Streamed response ended without content or tool calls') from e
-            delta = next_chunk.choices[0].delta
-            start_cost += _map_cost(next_chunk)
 
-        if delta.content is not None:
-            return OpenAIStreamTextResponse(delta.content, response, timestamp, start_cost)
-        else:
-            assert delta.tool_calls is not None, f'Expected delta with tool_calls, got {delta}'
-            return OpenAIStreamStructuredResponse(
-                response,
-                {c.index: c for c in delta.tool_calls},
-                timestamp,
-                start_cost,
-            )
+            timestamp = timestamp or datetime.fromtimestamp(chunk.created, tz=timezone.utc)
+            start_cost += _map_cost(chunk)
+
+            if chunk.choices:
+                delta = chunk.choices[0].delta
+
+                if delta.content is not None:
+                    return OpenAIStreamTextResponse(delta.content, response, timestamp, start_cost)
+                elif delta.tool_calls is not None:
+                    return OpenAIStreamStructuredResponse(
+                        response,
+                        {c.index: c for c in delta.tool_calls},
+                        timestamp,
+                        start_cost,
+                    )
+                # else continue until we get either delta.content or delta.tool_calls
 
     @staticmethod
     def _map_message(message: Message) -> chat.ChatCompletionMessageParam: