mirascope 2.0.0a5__py3-none-any.whl → 2.0.1__py3-none-any.whl

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

@@ -1,7 +1,9 @@
 """OpenAI Responses message encoding and request preparation."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
-from typing import TypedDict, cast
+from typing import TYPE_CHECKING, TypedDict, cast
 
 from openai import Omit
 from openai.types.responses import (
@@ -23,7 +25,7 @@ from openai.types.responses.response_input_param import (
     FunctionCallOutput,
     Message as ResponseInputMessageParam,
 )
-from openai.types.shared_params import Reasoning
+from openai.types.shared_params import Reasoning, ReasoningEffort
 from openai.types.shared_params.response_format_json_object import (
     ResponseFormatJSONObject,
 )
@@ -33,12 +35,12 @@ from .....exceptions import FeatureNotSupportedError
 from .....formatting import (
     Format,
     FormattableT,
-    _utils as _formatting_utils,
+    OutputParser,
     resolve_format,
 )
 from .....messages import AssistantMessage, Message, UserMessage
 from .....tools import FORMAT_TOOL_NAME, AnyToolSchema, BaseToolkit
-from ....base import Params, _utils as _base_utils
+from ....base import _utils as _base_utils
 from ...model_id import OpenAIModelId, model_name
 from ...model_info import (
     MODELS_WITHOUT_JSON_OBJECT_SUPPORT,
@@ -46,6 +48,20 @@ from ...model_info import (
     NON_REASONING_MODELS,
 )
 
+if TYPE_CHECKING:
+    from .....models import Params, ThinkingLevel
+
+# Thinking level to a float multiplier % of max tokens
+THINKING_LEVEL_TO_EFFORT: dict[ThinkingLevel, ReasoningEffort] = {
+    "default": "medium",
+    "none": "none",
+    "minimal": "minimal",
+    "low": "low",
+    "medium": "medium",
+    "high": "high",
+    "max": "xhigh",
+}
+
 
 class ResponseCreateKwargs(TypedDict, total=False):
     """Kwargs to the OpenAI `client.responses.create` method."""
@@ -103,7 +119,7 @@ def _encode_user_message(
             result.append(
                 FunctionCallOutput(
                     call_id=part.id,
-                    output=str(part.value),
+                    output=str(part.result),
                     type="function_call_output",
                 )
             )
@@ -201,13 +217,16 @@ def _convert_tool_to_function_tool_param(tool: AnyToolSchema) -> FunctionToolPar
     schema_dict = tool.parameters.model_dump(by_alias=True, exclude_none=True)
     schema_dict["type"] = "object"
     _base_utils.ensure_additional_properties_false(schema_dict)
+    strict = True if tool.strict is None else tool.strict
+    if strict:
+        _base_utils.ensure_all_properties_required(schema_dict)
 
     return FunctionToolParam(
         type="function",
         name=tool.name,
         description=tool.description,
         parameters=schema_dict,
-        strict=tool.strict,
+        strict=strict,
     )
 
 
@@ -237,12 +256,25 @@ def _create_strict_response_format(
     return response_format
 
 
-def _compute_reasoning(thinking: bool) -> Reasoning:
-    """Compute the OpenAI `Reasoning` config based on thinking settings."""
-    if thinking:
-        return {"effort": "medium", "summary": "auto"}
-    else:
-        return {"effort": "minimal"}
+def _compute_reasoning(
+    level: ThinkingLevel,
+    include_thoughts: bool,
+) -> Reasoning:
+    """Compute the OpenAI `Reasoning` config based on ThinkingConfig.
+
+    Args:
+        level: The thinking level
+        include_thoughts: Whether to include summary (True/False for auto)
+
+    Returns:
+        OpenAI Reasoning configuration
+    """
+    reasoning: Reasoning = {"effort": THINKING_LEVEL_TO_EFFORT.get(level) or "medium"}
+
+    if include_thoughts:
+        reasoning["summary"] = "auto"
+
+    return reasoning
 
 
 def encode_request(
@@ -250,7 +282,10 @@ def encode_request(
     model_id: OpenAIModelId,
     messages: Sequence[Message],
     tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-    format: type[FormattableT] | Format[FormattableT] | None,
+    format: type[FormattableT]
+    | Format[FormattableT]
+    | OutputParser[FormattableT]
+    | None,
     params: Params,
 ) -> tuple[Sequence[Message], Format[FormattableT] | None, ResponseCreateKwargs]:
     """Prepares a request for the `OpenAI.responses.create` method."""
@@ -283,16 +318,21 @@ def encode_request(
         if param_accessor.top_p is not None:
             kwargs["top_p"] = param_accessor.top_p
         if param_accessor.thinking is not None:
+            thinking_config = param_accessor.thinking
             if base_model_name in NON_REASONING_MODELS:
                 param_accessor.emit_warning_for_unused_param(
-                    "thinking", param_accessor.thinking, "openai", model_id
+                    "thinking", thinking_config, "openai", model_id
                 )
             else:
                 # Assume model supports reasoning unless explicitly listed as non-reasoning
                 # This ensures new reasoning models work immediately without code updates
-                kwargs["reasoning"] = _compute_reasoning(param_accessor.thinking)
-        if param_accessor.encode_thoughts_as_text:
-            encode_thoughts = True
+                level = thinking_config.get("level")
+                include_thoughts = thinking_config.get("include_thoughts", False)
+                kwargs["reasoning"] = _compute_reasoning(level, include_thoughts)
+
+            # Handle encode_thoughts_as_text from ThinkingConfig
+            if thinking_config.get("encode_thoughts_as_text"):
+                encode_thoughts = True
 
     tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
     openai_tools = [_convert_tool_to_function_tool_param(tool) for tool in tools]
@@ -305,9 +345,9 @@ def encode_request(
         if format.mode == "strict":
             kwargs["text"] = {"format": _create_strict_response_format(format)}
         elif format.mode == "tool":
-            format_tool_shared_utils = _formatting_utils.create_tool_schema(format)
+            format_tool_schema = format.create_tool_schema()
             openai_tools.append(
-                _convert_tool_to_function_tool_param(format_tool_shared_utils)
+                _convert_tool_to_function_tool_param(format_tool_schema)
             )
             if tools:
                 kwargs["tool_choice"] = ToolChoiceAllowedParam(

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

@@ -1,13 +1,16 @@
 """OpenAI Responses API client implementation."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
+from typing import TYPE_CHECKING
 from typing_extensions import Unpack
 
 from openai import AsyncOpenAI, BadRequestError as OpenAIBadRequestError, OpenAI
 
 from ....context import Context, DepsT
 from ....exceptions import BadRequestError, NotFoundError
-from ....formatting import Format, FormattableT
+from ....formatting import Format, FormattableT, OutputParser
 from ....messages import Message
 from ....responses import (
     AsyncContextResponse,
@@ -29,11 +32,14 @@ from ....tools import (
     Tool,
     Toolkit,
 )
-from ...base import BaseProvider, Params
+from ...base import BaseProvider
 from .. import _utils as _shared_utils
 from ..model_id import OpenAIModelId, model_name
 from . import _utils
 
+if TYPE_CHECKING:
+    from ....models import Params
+
 
 class OpenAIResponsesProvider(BaseProvider[OpenAI]):
     """The client for the OpenAI Responses API."""
@@ -67,7 +73,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> Response | Response[FormattableT]:
         """Generate an `llm.Response` by synchronously calling the OpenAI Responses API.
@@ -91,8 +100,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = self.client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -116,7 +126,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> AsyncResponse | AsyncResponse[FormattableT]:
         """Generate an `llm.AsyncResponse` by asynchronously calling the OpenAI Responses API.
@@ -140,8 +153,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = await self.async_client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -165,7 +179,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> StreamResponse | StreamResponse[FormattableT]:
         """Generate a `llm.StreamResponse` by synchronously streaming from the OpenAI Responses API.
@@ -192,8 +209,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -214,7 +232,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
         """Generate a `llm.AsyncStreamResponse` by asynchronously streaming from the OpenAI Responses API.
@@ -241,8 +262,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_async_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -266,7 +288,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> ContextResponse[DepsT] | ContextResponse[DepsT, FormattableT]:
         """Generate a `llm.ContextResponse` by synchronously calling the OpenAI Responses API with context.
@@ -291,8 +316,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = self.client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -319,7 +345,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> AsyncContextResponse[DepsT] | AsyncContextResponse[DepsT, FormattableT]:
         """Generate a `llm.AsyncContextResponse` by asynchronously calling the OpenAI Responses API with context.
@@ -344,8 +373,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = await self.async_client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -372,7 +402,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> ContextStreamResponse[DepsT] | ContextStreamResponse[DepsT, FormattableT]:
         """Generate a `llm.ContextStreamResponse` by synchronously streaming from the OpenAI Responses API with context.
@@ -401,8 +434,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -426,7 +460,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> (
         AsyncContextStreamResponse[DepsT]
@@ -458,8 +495,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_async_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 

mirascope/llm/providers/provider_id.py

@@ -6,6 +6,7 @@ KnownProviderId: TypeAlias = Literal[
     "anthropic",  # Anthropic provider via AnthropicProvider
     "anthropic-beta",  # Anthropic beta provider via AnthropicBetaProvider
     "google",  # Google provider via GoogleProvider
+    "mirascope",  # Mirascope Router provider via MirascopeProvider
     "mlx",  # Local inference powered by `mlx-lm`, via MLXProvider
     "ollama",  # Ollama provider via OllamaProvider
     "openai",  # OpenAI provider via OpenAIProvider (prefers Responses routing when available)

mirascope/llm/providers/provider_registry.py

@@ -1,12 +1,16 @@
 """Provider registry for managing provider instances and scopes."""
 
+import os
+from collections.abc import Sequence
+from dataclasses import dataclass
 from functools import lru_cache
 from typing import overload
 
-from ..exceptions import NoRegisteredProviderError
+from ..exceptions import MissingAPIKeyError, NoRegisteredProviderError
 from .anthropic import AnthropicProvider
 from .base import Provider
 from .google import GoogleProvider
+from .mirascope import MirascopeProvider
 from .mlx import MLXProvider
 from .ollama import OllamaProvider
 from .openai import OpenAIProvider
@@ -26,18 +30,64 @@ def reset_provider_registry() -> None:
     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",
-    "mlx-community/": "mlx",
-    "ollama/": "ollama",
-    "openai/": "openai",
-    "together/": "together",
+@dataclass(frozen=True)
+class ProviderDefault:
+    """Configuration for a provider in the auto-registration fallback chain.
+
+    When auto-registering a provider for a scope, the fallback chain is tried
+    in order. The first provider whose API key is available will be used.
+    """
+
+    provider_id: ProviderId
+    """The provider identifier."""
+
+    api_key_env_var: str | None
+    """Environment variable for the API key, or None if no key is required."""
+
+
+# Fallback chain for auto-registration: try providers in order until one has
+# its API key available. This enables automatic fallback to Mirascope Router
+# when direct provider keys are not set.
+DEFAULT_AUTO_REGISTER_SCOPES: dict[str, Sequence[ProviderDefault]] = {
+    "anthropic/": [
+        ProviderDefault("anthropic", "ANTHROPIC_API_KEY"),
+        ProviderDefault("mirascope", "MIRASCOPE_API_KEY"),
+    ],
+    "google/": [
+        ProviderDefault("google", "GOOGLE_API_KEY"),
+        ProviderDefault("mirascope", "MIRASCOPE_API_KEY"),
+    ],
+    "openai/": [
+        ProviderDefault("openai", "OPENAI_API_KEY"),
+        ProviderDefault("mirascope", "MIRASCOPE_API_KEY"),
+    ],
+    "together/": [
+        ProviderDefault("together", "TOGETHER_API_KEY"),
+        # No Mirascope fallback for together
+    ],
+    "ollama/": [
+        ProviderDefault("ollama", None),  # No API key required
+    ],
+    "mlx-community/": [
+        ProviderDefault("mlx", None),  # No API key required
+    ],
 }
 
 
+def _has_api_key(default: ProviderDefault) -> bool:
+    """Check if the API key for a provider default is available.
+
+    Args:
+        default: The provider default configuration to check.
+
+    Returns:
+        True if the API key is available or not required, False otherwise.
+    """
+    if default.api_key_env_var is None:
+        return True  # Provider doesn't require API key
+    return os.environ.get(default.api_key_env_var) is not None
+
+
 @lru_cache(maxsize=256)
 def provider_singleton(
     provider_id: ProviderId, *, api_key: str | None = None, base_url: str | None = None
@@ -60,6 +110,8 @@ def provider_singleton(
             return AnthropicProvider(api_key=api_key, base_url=base_url)
         case "google":
             return GoogleProvider(api_key=api_key, base_url=base_url)
+        case "mirascope":
+            return MirascopeProvider(api_key=api_key, base_url=base_url)
         case "mlx":  # pragma: no cover (MLX is only available on macOS)
             return MLXProvider()
         case "ollama":
@@ -172,6 +224,10 @@ def get_provider_for_model(model_id: str) -> Provider:
     If no explicit registration is found, checks for auto-registration defaults
     and automatically registers the provider on first use.
 
+    When auto-registering, providers are tried in fallback order. For example,
+    if ANTHROPIC_API_KEY is not set but MIRASCOPE_API_KEY is, the Mirascope
+    Router will be used as a fallback for anthropic/ models.
+
     Args:
         model_id: The full model ID (e.g., "anthropic/claude-4-5-sonnet").
 
@@ -179,7 +235,8 @@ def get_provider_for_model(model_id: str) -> Provider:
         The provider instance registered for this model.
 
     Raises:
-        ValueError: If no provider is registered or available for this model.
+        NoRegisteredProviderError: If no provider scope matches the model_id.
+        MissingAPIKeyError: If no provider in the fallback chain has its API key set.
 
     Example:
         ```python
@@ -196,6 +253,11 @@ def get_provider_for_model(model_id: str) -> Provider:
         # Auto-registration on first use:
         provider = get_provider_for_model("openai/gpt-4")
         # Automatically loads and registers OpenAIProvider() for "openai/"
+
+        # Fallback to Mirascope Router if direct key missing:
+        # (with MIRASCOPE_API_KEY set but not ANTHROPIC_API_KEY)
+        provider = get_provider_for_model("anthropic/claude-4-5-sonnet")
+        # Returns MirascopeProvider registered for "anthropic/" scope
         ```
     """
     # Try explicit registry first (longest match wins)
@@ -206,17 +268,32 @@ def get_provider_for_model(model_id: str) -> Provider:
         best_scope = max(matching_scopes, key=len)
         return PROVIDER_REGISTRY[best_scope]
 
-    # Fall back to auto-registration
+    # Fall back to auto-registration with fallback chain
     matching_defaults = [
         scope for scope in DEFAULT_AUTO_REGISTER_SCOPES if model_id.startswith(scope)
     ]
     if matching_defaults:
         best_scope = max(matching_defaults, key=len)
-        provider_id = DEFAULT_AUTO_REGISTER_SCOPES[best_scope]
-        provider = provider_singleton(provider_id)
-        # Auto-register for future calls
-        PROVIDER_REGISTRY[best_scope] = provider
-        return provider
-
-    # No provider found
+        fallback_chain = DEFAULT_AUTO_REGISTER_SCOPES[best_scope]
+
+        # Try each provider in the fallback chain
+        for default in fallback_chain:
+            if _has_api_key(default):
+                provider = provider_singleton(default.provider_id)
+                # Register for just this scope (not all provider's default scopes)
+                PROVIDER_REGISTRY[best_scope] = provider
+                return provider
+
+        # No provider in chain has API key - raise helpful error
+        primary = fallback_chain[0]
+        has_mirascope_fallback = any(
+            d.provider_id == "mirascope" for d in fallback_chain
+        )
+        raise MissingAPIKeyError(
+            provider_id=primary.provider_id,
+            env_var=primary.api_key_env_var or "",
+            has_mirascope_fallback=has_mirascope_fallback,
+        )
+
+    # No matching scope at all
     raise NoRegisteredProviderError(model_id)

mirascope/llm/providers/together/__init__.py

@@ -1,18 +1,6 @@
 """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")
+from .provider import TogetherProvider
 
 __all__ = [
     "TogetherProvider",

mirascope/llm/responses/__init__.py

@@ -1,16 +1,18 @@
 """The Responses module for LLM responses."""
 
 from . import _utils
+from .base_response import ResponseT
 from .base_stream_response import (
     AsyncChunkIterator,
     ChunkIterator,
     RawMessageChunk,
     RawStreamEventChunk,
     StreamResponseChunk,
+    StreamResponseT,
 )
 from .finish_reason import FinishReason, FinishReasonChunk
 from .response import AsyncContextResponse, AsyncResponse, ContextResponse, Response
-from .root_response import RootResponse
+from .root_response import AnyResponse, RootResponse
 from .stream_response import (
     AsyncContextStreamResponse,
     AsyncStreamResponse,
@@ -30,6 +32,7 @@ from .streams import (
 from .usage import Usage, UsageDeltaChunk
 
 __all__ = [
+    "AnyResponse",
     "AsyncChunkIterator",
     "AsyncContextResponse",
     "AsyncContextStreamResponse",
@@ -47,10 +50,12 @@ __all__ = [
     "RawMessageChunk",
     "RawStreamEventChunk",
     "Response",
+    "ResponseT",
     "RootResponse",
     "Stream",
     "StreamResponse",
     "StreamResponseChunk",
+    "StreamResponseT",
     "TextStream",
     "ThoughtStream",
     "ToolCallStream",