mirascope 2.0.0a2__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

mirascope/llm/providers/together/provider.py

@@ -0,0 +1,40 @@
+"""Together AI provider implementation."""
+
+from typing import ClassVar
+
+from ..openai.completions.base_provider import BaseOpenAICompletionsProvider
+
+
+class TogetherProvider(BaseOpenAICompletionsProvider):
+    """Provider for Together AI's OpenAI-compatible API.
+
+    Inherits from BaseOpenAICompletionsProvider with Together-specific configuration:
+    - Uses Together AI's API endpoint
+    - Requires TOGETHER_API_KEY
+
+    Usage:
+        Register the provider with model ID prefixes you want to use:
+
+        ```python
+        import llm
+
+        # Register for meta-llama models
+        llm.register_provider("together", "meta-llama/")
+
+        # Now you can use meta-llama models directly
+        @llm.call("meta-llama/Llama-3.3-70B-Instruct-Turbo")
+        def my_prompt():
+            return [llm.messages.user("Hello!")]
+        ```
+    """
+
+    id: ClassVar[str] = "together"
+    default_scope: ClassVar[str | list[str]] = []
+    default_base_url: ClassVar[str | None] = "https://api.together.xyz/v1"
+    api_key_env_var: ClassVar[str] = "TOGETHER_API_KEY"
+    api_key_required: ClassVar[bool] = True
+    provider_name: ClassVar[str | None] = "Together"
+
+    def _model_name(self, model_id: str) -> str:
+        """Return the model ID as-is for Together API."""
+        return model_id

mirascope/llm/responses/__init__.py

@@ -27,6 +27,7 @@ from .streams import (
     ThoughtStream,
     ToolCallStream,
 )
+from .usage import Usage, UsageDeltaChunk
 
 __all__ = [
     "AsyncChunkIterator",
@@ -53,5 +54,7 @@ __all__ = [
     "TextStream",
     "ThoughtStream",
     "ToolCallStream",
+    "Usage",
+    "UsageDeltaChunk",
     "_utils",
 ]

mirascope/llm/responses/base_response.py

@@ -9,9 +9,10 @@ from ..messages import AssistantMessage, Message
 from ..tools import FORMAT_TOOL_NAME, ToolkitT
 from .finish_reason import FinishReason
 from .root_response import RootResponse
+from .usage import Usage
 
 if TYPE_CHECKING:
-    from ..clients import ModelId, Params, Provider
+    from ..providers import ModelId, Params, ProviderId
 
 
 class BaseResponse(RootResponse[ToolkitT, FormattableT]):
@@ -21,34 +22,41 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
         self,
         *,
         raw: Any,  # noqa: ANN401
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         toolkit: ToolkitT,
         format: Format[FormattableT] | None = None,
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize a Response.
 
         Args:
             raw: The raw response from the LLM.
-            provider: The provider name (e.g. "anthropic", "openai:completions").
+            provider: The provider name (e.g. "anthropic", "openai").
             model_id: The model identifier that generated the response.
+            provider_model_name: Optional provider-specific model name. May include
+                provider-specific additional info (like api mode in "gpt-5:responses").
             params: The params used to generate the response (or None).
             toolkit: Toolkit containing all the tools used to generate the response.
             format: The `Format` for the expected structured output format (or None).
             input_messages: The message history before the final assistant message.
             assistant_message: The final assistant message containing the response content.
             finish_reason: The reason why the LLM finished generating a response.
+            usage: Token usage statistics for the response.
         """
         self.raw = raw
-        self.provider = provider
+        self.provider_id = provider_id
         self.model_id = model_id
+        self.provider_model_name = provider_model_name
         self.params = params
         self.toolkit = toolkit
         self.finish_reason = finish_reason
+        self.usage = usage
         self.format = format
 
         # Process content in the assistant message, organizing it by type and
@@ -84,8 +92,9 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
             assistant_message = AssistantMessage(
                 content=self.content,
                 name=assistant_message.name,
-                provider=assistant_message.provider,
+                provider_id=assistant_message.provider_id,
                 model_id=assistant_message.model_id,
+                provider_model_name=assistant_message.provider_model_name,
                 raw_message=assistant_message.raw_message,
             )
         self.messages = list(input_messages) + [assistant_message]

mirascope/llm/responses/base_stream_response.py

@@ -36,9 +36,10 @@ from .streams import (
     ThoughtStream,
     ToolCallStream,
 )
+from .usage import Usage, UsageDeltaChunk
 
 if TYPE_CHECKING:
-    from ..clients import ModelId, Params, Provider
+    from ..providers import ModelId, Params, ProviderId
 
 
 @dataclass(kw_only=True)
@@ -76,7 +77,11 @@ class RawMessageChunk:
 
 
 StreamResponseChunk: TypeAlias = (
-    AssistantContentChunk | FinishReasonChunk | RawStreamEventChunk | RawMessageChunk
+    AssistantContentChunk
+    | FinishReasonChunk
+    | RawStreamEventChunk
+    | RawMessageChunk
+    | UsageDeltaChunk
 )
 
 ChunkIterator: TypeAlias = Iterator[StreamResponseChunk]
@@ -157,32 +162,39 @@ class BaseStreamResponse(
     def __init__(
         self,
         *,
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         toolkit: ToolkitT,
         format: Format[FormattableT] | None = None,
         input_messages: Sequence[Message],
         chunk_iterator: ChunkIteratorT,
+        usage: Usage | None = None,
     ) -> None:
         """Initialize the BaseStreamResponse.
 
         Args:
-            provider: The provider name (e.g. "anthropic", "openai:completions").
+            provider: The provider name (e.g. "anthropic", "openai").
             model_id: The model identifier that generated the response.
+            provider_model_name: Optional provider-specific model name. May include
+                provider-specific additional info (like api mode in "gpt-5:responses").
             params: The params used to generate the response (or None).
             toolkit: Toolkit containing all the tools used to generate the response.
             format: The `Format` for the expected structured output format (or None).
             input_messages: The input messages that were sent to the LLM
+            usage: Token usage statistics for the response.
 
         The BaseStreamResponse will process the tuples to build the chunks and raw lists
         as the stream is consumed.
         """
 
-        self.provider = provider
+        self.provider_id = provider_id
         self.model_id = model_id
+        self.provider_model_name = provider_model_name
         self.params = params
         self.toolkit = toolkit
+        self.usage = usage
         self.format = format
 
         # Internal-only lists which we mutate (append) during chunk processing
@@ -206,8 +218,9 @@ class BaseStreamResponse(
 
         self._assistant_message = AssistantMessage(
             content=self._content,
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             raw_message=None,
         )
 
@@ -470,6 +483,14 @@ class BaseSyncStreamResponse(BaseStreamResponse[ChunkIterator, ToolkitT, Formatt
                 self._assistant_message.raw_message = chunk.raw_message
             elif chunk.type == "finish_reason_chunk":
                 self.finish_reason = chunk.finish_reason
+            elif chunk.type == "usage_delta_chunk":
+                if self.usage is None:
+                    self.usage = Usage()
+                self.usage.input_tokens += chunk.input_tokens
+                self.usage.output_tokens += chunk.output_tokens
+                self.usage.cache_read_tokens += chunk.cache_read_tokens
+                self.usage.cache_write_tokens += chunk.cache_write_tokens
+                self.usage.reasoning_tokens += chunk.reasoning_tokens
             else:
                 yield self._handle_chunk(chunk)
 
@@ -643,6 +664,14 @@ class BaseAsyncStreamResponse(
                 self._assistant_message.raw_message = chunk.raw_message
             elif chunk.type == "finish_reason_chunk":
                 self.finish_reason = chunk.finish_reason
+            elif chunk.type == "usage_delta_chunk":
+                if self.usage is None:
+                    self.usage = Usage()
+                self.usage.input_tokens += chunk.input_tokens
+                self.usage.output_tokens += chunk.output_tokens
+                self.usage.cache_read_tokens += chunk.cache_read_tokens
+                self.usage.cache_write_tokens += chunk.cache_write_tokens
+                self.usage.reasoning_tokens += chunk.reasoning_tokens
             else:
                 yield self._handle_chunk(chunk)
 

mirascope/llm/responses/finish_reason.py

@@ -15,6 +15,7 @@ class FinishReason(str, Enum):
 
     MAX_TOKENS = "max_tokens"
     REFUSAL = "refusal"
+    CONTEXT_LENGTH_EXCEEDED = "context_length_exceeded"
 
 
 @dataclass(kw_only=True)

mirascope/llm/responses/response.py

@@ -18,11 +18,13 @@ from ..tools import (
     Tool,
     Toolkit,
 )
+from ..types import Jsonable
 from .base_response import BaseResponse
 from .finish_reason import FinishReason
+from .usage import Usage
 
 if TYPE_CHECKING:
-    from ..clients import ModelId, Params, Provider
+    from ..providers import ModelId, Params, ProviderId
 
 
 class Response(BaseResponse[Toolkit, FormattableT]):
@@ -32,30 +34,34 @@ class Response(BaseResponse[Toolkit, FormattableT]):
         self,
         *,
         raw: Any,  # noqa: ANN401
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[Tool] | Toolkit | None = None,
         format: Format[FormattableT] | None = None,
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize a `Response`."""
         toolkit = tools if isinstance(tools, Toolkit) else Toolkit(tools=tools)
         super().__init__(
             raw=raw,
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
-    def execute_tools(self) -> Sequence[ToolOutput]:
+    def execute_tools(self) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Returns:
@@ -101,14 +107,16 @@ class AsyncResponse(BaseResponse[AsyncToolkit, FormattableT]):
         self,
         *,
         raw: Any,  # noqa: ANN401
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
         format: Format[FormattableT] | None = None,
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize an `AsyncResponse`."""
         toolkit = (
@@ -116,17 +124,19 @@ class AsyncResponse(BaseResponse[AsyncToolkit, FormattableT]):
         )
         super().__init__(
             raw=raw,
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
-    async def execute_tools(self) -> Sequence[ToolOutput]:
+    async def execute_tools(self) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Returns:
@@ -179,8 +189,9 @@ class ContextResponse(
         self,
         *,
         raw: Any,  # noqa: ANN401
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
@@ -189,6 +200,7 @@ class ContextResponse(
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize a `ContextResponse`."""
         toolkit = (
@@ -196,17 +208,19 @@ class ContextResponse(
         )
         super().__init__(
             raw=raw,
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
-    def execute_tools(self, ctx: Context[DepsT]) -> Sequence[ToolOutput]:
+    def execute_tools(self, ctx: Context[DepsT]) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Args:
@@ -265,8 +279,9 @@ class AsyncContextResponse(
         self,
         *,
         raw: Any,  # noqa: ANN401
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
@@ -275,6 +290,7 @@ class AsyncContextResponse(
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize an `AsyncContextResponse`."""
         toolkit = (
@@ -284,17 +300,21 @@ class AsyncContextResponse(
         )
         super().__init__(
             raw=raw,
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
             input_messages=input_messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
         )
 
-    async def execute_tools(self, ctx: Context[DepsT]) -> Sequence[ToolOutput]:
+    async def execute_tools(
+        self, ctx: Context[DepsT]
+    ) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Args:

mirascope/llm/responses/root_response.py

@@ -11,10 +11,11 @@ from ..messages import Message
 from ..tools import ToolkitT
 from . import _utils
 from .finish_reason import FinishReason
+from .usage import Usage
 
 if TYPE_CHECKING:
-    from ..clients import ModelId, Params, Provider
     from ..models import Model
+    from ..providers import ModelId, Params, ProviderId
 
 
 class RootResponse(Generic[ToolkitT, FormattableT], ABC):
@@ -23,7 +24,7 @@ class RootResponse(Generic[ToolkitT, FormattableT], ABC):
     raw: Any
     """The raw response from the LLM."""
 
-    provider: "Provider"
+    provider_id: "ProviderId"
     """The provider that generated this response."""
 
     model_id: "ModelId"
@@ -55,12 +56,15 @@ class RootResponse(Generic[ToolkitT, FormattableT], ABC):
     """
     finish_reason: FinishReason | None
     """The reason why the LLM finished generating a response, if set.
-    
+
     `finish_reason` is only set if the response did not finish generating normally,
     e.g. `FinishReason.MAX_TOKENS` if the model ran out of tokens before completing.
     When the response generates normally, `response.finish_reason` will be `None`.
     """
 
+    usage: Usage | None
+    """Token usage statistics for this response, if available."""
+
     format: Format[FormattableT] | None
     """The `Format` describing the structured response format, if available."""
 
@@ -116,7 +120,9 @@ class RootResponse(Generic[ToolkitT, FormattableT], ABC):
             return None
 
         formattable = self.format.formattable
-        if formattable is None or formattable is NoneType:
+        if formattable is None or formattable is NoneType:  # pyright: ignore[reportUnnecessaryComparison]
+            # note: pyright claims the None comparison is unnecessary, but removing it
+            # introduces type errors.
             return None  # pragma: no cover
 
         if partial:
@@ -165,13 +171,6 @@ class RootResponse(Generic[ToolkitT, FormattableT], ABC):
     @property
     def model(self) -> "Model":
         """A `Model` with parameters matching this response."""
-        from ..models import Model, get_model_from_context
-
-        if context_model := get_model_from_context():
-            return context_model
+        from ..models import use_model  # Dynamic import to avoid circular dependency
 
-        return Model(
-            provider=self.provider,
-            model_id=self.model_id,
-            **self.params,
-        )
+        return use_model(self.model_id, **self.params)

mirascope/llm/responses/stream_response.py

@@ -18,6 +18,7 @@ from ..tools import (
     Tool,
     Toolkit,
 )
+from ..types import Jsonable
 from .base_stream_response import (
     AsyncChunkIterator,
     BaseAsyncStreamResponse,
@@ -26,7 +27,7 @@ from .base_stream_response import (
 )
 
 if TYPE_CHECKING:
-    from ..clients import ModelId, Params, Provider
+    from ..providers import ModelId, Params, ProviderId
 
 
 class StreamResponse(BaseSyncStreamResponse[Toolkit, FormattableT]):
@@ -76,8 +77,8 @@ class StreamResponse(BaseSyncStreamResponse[Toolkit, FormattableT]):
         from mirascope import llm
 
         @llm.call(
-            provider="openai:completions",
-            model_id="gpt-4o-mini",
+            provider_id="openai",
+            model_id="openai/gpt-5-mini",
         )
         def answer_question(question: str) -> str:
             return f"Answer this question: {question}"
@@ -93,8 +94,9 @@ class StreamResponse(BaseSyncStreamResponse[Toolkit, FormattableT]):
     def __init__(
         self,
         *,
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[Tool] | Toolkit | None = None,
         format: Format[FormattableT] | None = None,
@@ -104,8 +106,9 @@ class StreamResponse(BaseSyncStreamResponse[Toolkit, FormattableT]):
         """Initialize a `StreamResponse`."""
         toolkit = tools if isinstance(tools, Toolkit) else Toolkit(tools=tools)
         super().__init__(
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
@@ -113,7 +116,7 @@ class StreamResponse(BaseSyncStreamResponse[Toolkit, FormattableT]):
             chunk_iterator=chunk_iterator,
         )
 
-    def execute_tools(self) -> Sequence[ToolOutput]:
+    def execute_tools(self) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Returns:
@@ -201,8 +204,8 @@ class AsyncStreamResponse(BaseAsyncStreamResponse[AsyncToolkit, FormattableT]):
         from mirascope import llm
 
         @llm.call(
-            provider="openai:completions",
-            model_id="gpt-4o-mini",
+            provider_id="openai",
+            model_id="openai/gpt-5-mini",
         )
         async def answer_question(question: str) -> str:
             return f"Answer this question: {question}"
@@ -218,8 +221,9 @@ class AsyncStreamResponse(BaseAsyncStreamResponse[AsyncToolkit, FormattableT]):
     def __init__(
         self,
         *,
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
         format: Format[FormattableT] | None = None,
@@ -231,8 +235,9 @@ class AsyncStreamResponse(BaseAsyncStreamResponse[AsyncToolkit, FormattableT]):
             tools if isinstance(tools, AsyncToolkit) else AsyncToolkit(tools=tools)
         )
         super().__init__(
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
@@ -240,7 +245,7 @@ class AsyncStreamResponse(BaseAsyncStreamResponse[AsyncToolkit, FormattableT]):
             chunk_iterator=chunk_iterator,
         )
 
-    async def execute_tools(self) -> Sequence[ToolOutput]:
+    async def execute_tools(self) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Returns:
@@ -285,7 +290,8 @@ class AsyncStreamResponse(BaseAsyncStreamResponse[AsyncToolkit, FormattableT]):
 
 
 class ContextStreamResponse(
-    BaseSyncStreamResponse[ContextToolkit, FormattableT], Generic[DepsT, FormattableT]
+    BaseSyncStreamResponse[ContextToolkit[DepsT], FormattableT],
+    Generic[DepsT, FormattableT],
 ):
     """A `ContextStreamResponse` wraps response content from the LLM with a streaming interface.
 
@@ -333,8 +339,8 @@ class ContextStreamResponse(
         from mirascope import llm
 
         @llm.call(
-            provider="openai:completions",
-            model_id="gpt-4o-mini",
+            provider_id="openai",
+            model_id="openai/gpt-5-mini",
         )
         def answer_question(ctx: llm.Context, question: str) -> str:
             return f"Answer this question: {question}"
@@ -351,8 +357,9 @@ class ContextStreamResponse(
     def __init__(
         self,
         *,
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
@@ -366,8 +373,9 @@ class ContextStreamResponse(
             tools if isinstance(tools, ContextToolkit) else ContextToolkit(tools=tools)
         )
         super().__init__(
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
@@ -375,7 +383,7 @@ class ContextStreamResponse(
             chunk_iterator=chunk_iterator,
         )
 
-    def execute_tools(self, ctx: Context[DepsT]) -> Sequence[ToolOutput]:
+    def execute_tools(self, ctx: Context[DepsT]) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Args:
@@ -426,7 +434,7 @@ class ContextStreamResponse(
 
 
 class AsyncContextStreamResponse(
-    BaseAsyncStreamResponse[AsyncContextToolkit, FormattableT],
+    BaseAsyncStreamResponse[AsyncContextToolkit[DepsT], FormattableT],
     Generic[DepsT, FormattableT],
 ):
     """An `AsyncContextStreamResponse` wraps response content from the LLM with a streaming interface.
@@ -475,8 +483,8 @@ class AsyncContextStreamResponse(
         from mirascope import llm
 
         @llm.call(
-            provider="openai:completions",
-            model_id="gpt-4o-mini",
+            provider_id="openai",
+            model_id="openai/gpt-5-mini",
         )
         async def answer_question(ctx: llm.Context, question: str) -> str:
             return f"Answer this question: {question}"
@@ -493,8 +501,9 @@ class AsyncContextStreamResponse(
     def __init__(
         self,
         *,
-        provider: "Provider",
+        provider_id: "ProviderId",
         model_id: "ModelId",
+        provider_model_name: str,
         params: "Params",
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
@@ -510,8 +519,9 @@ class AsyncContextStreamResponse(
             else AsyncContextToolkit(tools=tools)
         )
         super().__init__(
-            provider=provider,
+            provider_id=provider_id,
             model_id=model_id,
+            provider_model_name=provider_model_name,
             params=params,
             toolkit=toolkit,
             format=format,
@@ -519,7 +529,9 @@ class AsyncContextStreamResponse(
             chunk_iterator=chunk_iterator,
         )
 
-    async def execute_tools(self, ctx: Context[DepsT]) -> Sequence[ToolOutput]:
+    async def execute_tools(
+        self, ctx: Context[DepsT]
+    ) -> Sequence[ToolOutput[Jsonable]]:
         """Execute and return all of the tool calls in the response.
 
         Args: