mirascope 2.0.0a3__py3-none-any.whl → 2.0.0a5__py3-none-any.whl

mirascope/llm/providers/openai/responses/_utils/decode.py

@@ -29,6 +29,8 @@ from .....responses import (
     FinishReasonChunk,
     RawMessageChunk,
     RawStreamEventChunk,
+    Usage,
+    UsageDeltaChunk,
 )
 from ...model_id import OpenAIModelId, model_name
 
@@ -38,6 +40,33 @@ INCOMPLETE_DETAILS_TO_FINISH_REASON = {
 }
 
 
+def _decode_usage(
+    usage: openai_types.ResponseUsage | None,
+) -> Usage | None:
+    """Convert OpenAI ResponseUsage to Mirascope Usage."""
+    if usage is None:  # pragma: no cover
+        return None
+
+    return Usage(
+        input_tokens=usage.input_tokens,
+        output_tokens=usage.output_tokens,
+        cache_read_tokens=(
+            usage.input_tokens_details.cached_tokens
+            if usage.input_tokens_details
+            else None
+        )
+        or 0,
+        cache_write_tokens=0,
+        reasoning_tokens=(
+            usage.output_tokens_details.reasoning_tokens
+            if usage.output_tokens_details
+            else None
+        )
+        or 0,
+        raw=usage,
+    )
+
+
 def _serialize_output_item(
     item: openai_types.ResponseOutputItem,
 ) -> dict[str, Any]:
@@ -48,9 +77,9 @@ def _serialize_output_item(
 def decode_response(
     response: openai_types.Response,
     model_id: OpenAIModelId,
-    provider_id: Literal["openai", "openai:responses"],
-) -> tuple[AssistantMessage, FinishReason | None]:
-    """Convert OpenAI Responses Response to mirascope AssistantMessage."""
+    provider_id: str,
+) -> tuple[AssistantMessage, FinishReason | None, Usage | None]:
+    """Convert OpenAI Responses Response to mirascope AssistantMessage and usage."""
     parts: list[AssistantContentPart] = []
     finish_reason: FinishReason | None = None
     refused = False
@@ -100,7 +129,8 @@ def decode_response(
         ],
     )
 
-    return assistant_message, finish_reason
+    usage = _decode_usage(response.usage)
+    return assistant_message, finish_reason, usage
 
 
 class _OpenAIResponsesChunkProcessor:
@@ -176,6 +206,27 @@ class _OpenAIResponsesChunkProcessor:
                 if self.refusal_encountered:
                     yield FinishReasonChunk(finish_reason=FinishReason.REFUSAL)
 
+                # Emit usage delta if present
+                if event.response.usage:
+                    usage = event.response.usage
+                    yield UsageDeltaChunk(
+                        input_tokens=usage.input_tokens,
+                        output_tokens=usage.output_tokens,
+                        cache_read_tokens=(
+                            usage.input_tokens_details.cached_tokens
+                            if usage.input_tokens_details
+                            else None
+                        )
+                        or 0,
+                        cache_write_tokens=0,
+                        reasoning_tokens=(
+                            usage.output_tokens_details.reasoning_tokens
+                            if usage.output_tokens_details
+                            else None
+                        )
+                        or 0,
+                    )
+
 
 def decode_stream(
     openai_stream: Stream[ResponseStreamEvent],

mirascope/llm/providers/openai/responses/_utils/encode.py

@@ -40,8 +40,11 @@ from .....messages import AssistantMessage, Message, UserMessage
 from .....tools import FORMAT_TOOL_NAME, AnyToolSchema, BaseToolkit
 from ....base import Params, _utils as _base_utils
 from ...model_id import OpenAIModelId, model_name
-from ...model_info import NON_REASONING_MODELS
-from ...shared import _utils as _shared_utils
+from ...model_info import (
+    MODELS_WITHOUT_JSON_OBJECT_SUPPORT,
+    MODELS_WITHOUT_JSON_SCHEMA_SUPPORT,
+    NON_REASONING_MODELS,
+)
 
 
 class ResponseCreateKwargs(TypedDict, total=False):
@@ -197,7 +200,7 @@ def _convert_tool_to_function_tool_param(tool: AnyToolSchema) -> FunctionToolPar
     """Convert a Mirascope ToolSchema to OpenAI Responses FunctionToolParam."""
     schema_dict = tool.parameters.model_dump(by_alias=True, exclude_none=True)
     schema_dict["type"] = "object"
-    _shared_utils.ensure_additional_properties_false(schema_dict)
+    _base_utils.ensure_additional_properties_false(schema_dict)
 
     return FunctionToolParam(
         type="function",
@@ -220,7 +223,7 @@ def _create_strict_response_format(
         ResponseFormatTextJSONSchemaConfigParam for strict structured outputs
     """
     schema = format.schema.copy()
-    _shared_utils.ensure_additional_properties_false(schema)
+    _base_utils.ensure_additional_properties_false(schema)
 
     response_format: ResponseFormatTextJSONSchemaConfigParam = {
         "type": "json_schema",
@@ -294,9 +297,7 @@ def encode_request(
     tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
     openai_tools = [_convert_tool_to_function_tool_param(tool) for tool in tools]
 
-    model_supports_strict = (
-        model_id not in _shared_utils.MODELS_WITHOUT_JSON_SCHEMA_SUPPORT
-    )
+    model_supports_strict = model_id not in MODELS_WITHOUT_JSON_SCHEMA_SUPPORT
     default_mode = "strict" if model_supports_strict else "tool"
 
     format = resolve_format(format, default_mode=default_mode)
@@ -323,8 +324,7 @@ def encode_request(
                     name=FORMAT_TOOL_NAME,
                 )
         elif (
-            format.mode == "json"
-            and model_id not in _shared_utils.MODELS_WITHOUT_JSON_OBJECT_SUPPORT
+            format.mode == "json" and model_id not in MODELS_WITHOUT_JSON_OBJECT_SUPPORT
         ):
             kwargs["text"] = {"format": ResponseFormatJSONObject(type="json_object")}
 

mirascope/llm/providers/openai/responses/provider.py

@@ -1,12 +1,12 @@
 """OpenAI Responses API client implementation."""
 
 from collections.abc import Sequence
-from typing import Literal
 from typing_extensions import Unpack
 
-from openai import AsyncOpenAI, OpenAI
+from openai import AsyncOpenAI, BadRequestError as OpenAIBadRequestError, OpenAI
 
 from ....context import Context, DepsT
+from ....exceptions import BadRequestError, NotFoundError
 from ....formatting import Format, FormattableT
 from ....messages import Message
 from ....responses import (
@@ -30,6 +30,7 @@ from ....tools import (
     Toolkit,
 )
 from ...base import BaseProvider, Params
+from .. import _utils as _shared_utils
 from ..model_id import OpenAIModelId, model_name
 from . import _utils
 
@@ -39,20 +40,26 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
 
     id = "openai:responses"
     default_scope = "openai/"
+    error_map = {
+        **_shared_utils.OPENAI_ERROR_MAP,
+        OpenAIBadRequestError: lambda e: NotFoundError
+        if hasattr(e, "code") and e.code == "model_not_found"  # pyright: ignore[reportAttributeAccessIssue,reportUnknownMemberType]
+        else BadRequestError,
+    }
 
     def __init__(
         self,
         *,
         api_key: str | None = None,
         base_url: str | None = None,
-        wrapped_by_openai_provider: bool = False,
     ) -> None:
         """Initialize the OpenAI Responses client."""
         self.client = OpenAI(api_key=api_key, base_url=base_url)
         self.async_client = AsyncOpenAI(api_key=api_key, base_url=base_url)
-        self.active_provider_id: Literal["openai", "openai:responses"] = (
-            "openai" if wrapped_by_openai_provider else "openai:responses"
-        )
+
+    def get_error_status(self, e: Exception) -> int | None:
+        """Extract HTTP status code from OpenAI exception."""
+        return getattr(e, "status_code", None)
 
     def _call(
         self,
@@ -82,17 +89,16 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             format=format,
             params=params,
         )
-
         openai_response = self.client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return Response(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -100,6 +106,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -131,17 +138,16 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             format=format,
             params=params,
         )
-
         openai_response = await self.async_client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncResponse(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -149,6 +155,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -180,7 +187,6 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             format=format,
             params=params,
         )
-
         openai_stream = self.client.responses.create(
             **kwargs,
             stream=True,
@@ -192,7 +198,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return StreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -230,7 +236,6 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             format=format,
             params=params,
         )
-
         openai_stream = await self.async_client.responses.create(
             **kwargs,
             stream=True,
@@ -242,7 +247,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncStreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -284,17 +289,16 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             format=format,
             params=params,
         )
-
         openai_response = self.client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return ContextResponse(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -302,6 +306,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -337,17 +342,16 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             format=format,
             params=params,
         )
-
         openai_response = await self.async_client.responses.create(**kwargs)
 
-        assistant_message, finish_reason = _utils.decode_response(
-            openai_response, model_id, self.active_provider_id
+        assistant_message, finish_reason, usage = _utils.decode_response(
+            openai_response, model_id, self.id
         )
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncContextResponse(
             raw=openai_response,
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -355,6 +359,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             input_messages=messages,
             assistant_message=assistant_message,
             finish_reason=finish_reason,
+            usage=usage,
             format=format,
         )
 
@@ -402,7 +407,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return ContextStreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,
@@ -459,7 +464,7 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         provider_model_name = model_name(model_id, "responses")
 
         return AsyncContextStreamResponse(
-            provider_id=self.active_provider_id,
+            provider_id=self.id,
             model_id=model_id,
             provider_model_name=provider_model_name,
             params=params,

mirascope/llm/providers/provider_id.py

@@ -4,10 +4,20 @@ from typing import Literal, TypeAlias, get_args
 
 KnownProviderId: TypeAlias = Literal[
     "anthropic",  # Anthropic provider via AnthropicProvider
+    "anthropic-beta",  # Anthropic beta provider via AnthropicBetaProvider
     "google",  # Google provider via GoogleProvider
-    "openai",  # OpenAI provider via OpenAIProvider
     "mlx",  # Local inference powered by `mlx-lm`, via MLXProvider
+    "ollama",  # Ollama provider via OllamaProvider
+    "openai",  # OpenAI provider via OpenAIProvider (prefers Responses routing when available)
+    "together",  # Together AI provider via TogetherProvider
 ]
 KNOWN_PROVIDER_IDS = get_args(KnownProviderId)
 
 ProviderId = KnownProviderId | str
+
+OpenAICompletionsCompatibleProviderId: TypeAlias = Literal[
+    "ollama",  # Ollama (OpenAI-compatible)
+    "openai",  # OpenAI via OpenAIProvider (routes to completions)
+    "openai:completions",  # OpenAI Completions API directly
+    "together",  # Together AI (OpenAI-compatible)
+]

mirascope/llm/providers/provider_registry.py

@@ -1,26 +1,81 @@
 """Provider registry for managing provider instances and scopes."""
 
+from functools import lru_cache
 from typing import overload
 
 from ..exceptions import NoRegisteredProviderError
+from .anthropic import AnthropicProvider
 from .base import Provider
-from .load_provider import load_provider
+from .google import GoogleProvider
+from .mlx import MLXProvider
+from .ollama import OllamaProvider
+from .openai import OpenAIProvider
+from .openai.completions.provider import OpenAICompletionsProvider
+from .openai.responses.provider import OpenAIResponsesProvider
 from .provider_id import ProviderId
+from .together import TogetherProvider
 
 # Global registry mapping scopes to providers
 # Scopes are matched by prefix (longest match wins)
 PROVIDER_REGISTRY: dict[str, Provider] = {}
 
+
+def reset_provider_registry() -> None:
+    """Resets the provider registry, clearing all registered providers."""
+    PROVIDER_REGISTRY.clear()
+    provider_singleton.cache_clear()
+
+
 # Default auto-registration mapping for built-in providers
 # These providers will be automatically registered on first use
 DEFAULT_AUTO_REGISTER_SCOPES: dict[str, ProviderId] = {
     "anthropic/": "anthropic",
     "google/": "google",
-    "openai/": "openai",
     "mlx-community/": "mlx",
+    "ollama/": "ollama",
+    "openai/": "openai",
+    "together/": "together",
 }
 
 
+@lru_cache(maxsize=256)
+def provider_singleton(
+    provider_id: ProviderId, *, api_key: str | None = None, base_url: str | None = None
+) -> Provider:
+    """Create a cached provider instance for the specified provider id.
+
+    Args:
+        provider_id: The provider name ("openai", "anthropic", or "google").
+        api_key: API key for authentication. If None, uses provider-specific env var.
+        base_url: Base URL for the API. If None, uses provider-specific env var.
+
+    Returns:
+        A cached provider instance for the specified provider with the given parameters.
+
+    Raises:
+        ValueError: If the provider_id is not supported.
+    """
+    match provider_id:
+        case "anthropic":
+            return AnthropicProvider(api_key=api_key, base_url=base_url)
+        case "google":
+            return GoogleProvider(api_key=api_key, base_url=base_url)
+        case "mlx":  # pragma: no cover (MLX is only available on macOS)
+            return MLXProvider()
+        case "ollama":
+            return OllamaProvider(api_key=api_key, base_url=base_url)
+        case "openai":
+            return OpenAIProvider(api_key=api_key, base_url=base_url)
+        case "openai:completions":
+            return OpenAICompletionsProvider(api_key=api_key, base_url=base_url)
+        case "openai:responses":
+            return OpenAIResponsesProvider(api_key=api_key, base_url=base_url)
+        case "together":
+            return TogetherProvider(api_key=api_key, base_url=base_url)
+        case _:  # pragma: no cover
+            raise ValueError(f"Unknown provider: '{provider_id}'")
+
+
 @overload
 def register_provider(
     provider: Provider,
@@ -98,7 +153,7 @@ def register_provider(
     """
 
     if isinstance(provider, str):
-        provider = load_provider(provider, api_key=api_key, base_url=base_url)
+        provider = provider_singleton(provider, api_key=api_key, base_url=base_url)
 
     if scope is None:
         scope = provider.default_scope
@@ -158,7 +213,7 @@ def get_provider_for_model(model_id: str) -> Provider:
     if matching_defaults:
         best_scope = max(matching_defaults, key=len)
         provider_id = DEFAULT_AUTO_REGISTER_SCOPES[best_scope]
-        provider = load_provider(provider_id)
+        provider = provider_singleton(provider_id)
         # Auto-register for future calls
         PROVIDER_REGISTRY[best_scope] = provider
         return provider

mirascope/llm/providers/together/__init__.py

@@ -0,0 +1,19 @@
+"""Together AI provider implementation."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .provider import TogetherProvider
+else:
+    try:
+        from .provider import TogetherProvider
+    except ImportError:  # pragma: no cover
+        from .._missing_import_stubs import (
+            create_provider_stub,
+        )
+
+        TogetherProvider = create_provider_stub("openai", "TogetherProvider")
+
+__all__ = [
+    "TogetherProvider",
+]

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,6 +9,7 @@ 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 ..providers import ModelId, Params, ProviderId
@@ -30,6 +31,7 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
         input_messages: Sequence[Message],
         assistant_message: AssistantMessage,
         finish_reason: FinishReason | None,
+        usage: Usage | None,
     ) -> None:
         """Initialize a Response.
 
@@ -45,6 +47,7 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
             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_id = provider_id
@@ -53,6 +56,7 @@ class BaseResponse(RootResponse[ToolkitT, FormattableT]):
         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

mirascope/llm/responses/base_stream_response.py

@@ -36,6 +36,7 @@ from .streams import (
     ThoughtStream,
     ToolCallStream,
 )
+from .usage import Usage, UsageDeltaChunk
 
 if TYPE_CHECKING:
     from ..providers import ModelId, Params, ProviderId
@@ -76,7 +77,11 @@ class RawMessageChunk:
 
 
 StreamResponseChunk: TypeAlias = (
-    AssistantContentChunk | FinishReasonChunk | RawStreamEventChunk | RawMessageChunk
+    AssistantContentChunk
+    | FinishReasonChunk
+    | RawStreamEventChunk
+    | RawMessageChunk
+    | UsageDeltaChunk
 )
 
 ChunkIterator: TypeAlias = Iterator[StreamResponseChunk]
@@ -165,6 +170,7 @@ class BaseStreamResponse(
         format: Format[FormattableT] | None = None,
         input_messages: Sequence[Message],
         chunk_iterator: ChunkIteratorT,
+        usage: Usage | None = None,
     ) -> None:
         """Initialize the BaseStreamResponse.
 
@@ -177,6 +183,7 @@ class BaseStreamResponse(
             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.
@@ -187,6 +194,7 @@ class BaseStreamResponse(
         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
@@ -475,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)
 
@@ -648,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)