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

mirascope/llm/providers/openai/model_info.py

@@ -0,0 +1,246 @@
+"""OpenAI model information.
+
+This file is auto-generated by scripts/model_features/codegen_openai.py
+Do not edit manually - run the codegen script to update."""
+
+from typing import Literal
+
+OpenAIKnownModels = Literal[
+    "openai/chatgpt-4o-latest",
+    "openai/chatgpt-4o-latest:completions",
+    "openai/chatgpt-4o-latest:responses",
+    "openai/codex-mini-latest",
+    "openai/codex-mini-latest:responses",
+    "openai/gpt-3.5-turbo",
+    "openai/gpt-3.5-turbo:completions",
+    "openai/gpt-3.5-turbo:responses",
+    "openai/gpt-3.5-turbo-0125",
+    "openai/gpt-3.5-turbo-0125:completions",
+    "openai/gpt-3.5-turbo-0125:responses",
+    "openai/gpt-3.5-turbo-1106",
+    "openai/gpt-3.5-turbo-1106:completions",
+    "openai/gpt-3.5-turbo-1106:responses",
+    "openai/gpt-3.5-turbo-16k",
+    "openai/gpt-3.5-turbo-16k:completions",
+    "openai/gpt-4",
+    "openai/gpt-4:completions",
+    "openai/gpt-4:responses",
+    "openai/gpt-4-0125-preview",
+    "openai/gpt-4-0125-preview:completions",
+    "openai/gpt-4-0125-preview:responses",
+    "openai/gpt-4-0613",
+    "openai/gpt-4-0613:completions",
+    "openai/gpt-4-0613:responses",
+    "openai/gpt-4-1106-preview",
+    "openai/gpt-4-1106-preview:completions",
+    "openai/gpt-4-1106-preview:responses",
+    "openai/gpt-4-turbo",
+    "openai/gpt-4-turbo:completions",
+    "openai/gpt-4-turbo:responses",
+    "openai/gpt-4-turbo-2024-04-09",
+    "openai/gpt-4-turbo-2024-04-09:completions",
+    "openai/gpt-4-turbo-2024-04-09:responses",
+    "openai/gpt-4-turbo-preview",
+    "openai/gpt-4-turbo-preview:completions",
+    "openai/gpt-4-turbo-preview:responses",
+    "openai/gpt-4.1",
+    "openai/gpt-4.1:completions",
+    "openai/gpt-4.1:responses",
+    "openai/gpt-4.1-2025-04-14",
+    "openai/gpt-4.1-2025-04-14:completions",
+    "openai/gpt-4.1-2025-04-14:responses",
+    "openai/gpt-4.1-mini",
+    "openai/gpt-4.1-mini:completions",
+    "openai/gpt-4.1-mini:responses",
+    "openai/gpt-4.1-mini-2025-04-14",
+    "openai/gpt-4.1-mini-2025-04-14:completions",
+    "openai/gpt-4.1-mini-2025-04-14:responses",
+    "openai/gpt-4.1-nano",
+    "openai/gpt-4.1-nano:completions",
+    "openai/gpt-4.1-nano:responses",
+    "openai/gpt-4.1-nano-2025-04-14",
+    "openai/gpt-4.1-nano-2025-04-14:completions",
+    "openai/gpt-4.1-nano-2025-04-14:responses",
+    "openai/gpt-4o",
+    "openai/gpt-4o:completions",
+    "openai/gpt-4o:responses",
+    "openai/gpt-4o-2024-05-13",
+    "openai/gpt-4o-2024-05-13:completions",
+    "openai/gpt-4o-2024-05-13:responses",
+    "openai/gpt-4o-2024-08-06",
+    "openai/gpt-4o-2024-08-06:completions",
+    "openai/gpt-4o-2024-08-06:responses",
+    "openai/gpt-4o-2024-11-20",
+    "openai/gpt-4o-2024-11-20:completions",
+    "openai/gpt-4o-2024-11-20:responses",
+    "openai/gpt-4o-mini",
+    "openai/gpt-4o-mini:completions",
+    "openai/gpt-4o-mini:responses",
+    "openai/gpt-4o-mini-2024-07-18",
+    "openai/gpt-4o-mini-2024-07-18:completions",
+    "openai/gpt-4o-mini-2024-07-18:responses",
+    "openai/gpt-4o-mini-search-preview",
+    "openai/gpt-4o-mini-search-preview:completions",
+    "openai/gpt-4o-mini-search-preview-2025-03-11",
+    "openai/gpt-4o-mini-search-preview-2025-03-11:completions",
+    "openai/gpt-4o-search-preview",
+    "openai/gpt-4o-search-preview:completions",
+    "openai/gpt-4o-search-preview-2025-03-11",
+    "openai/gpt-4o-search-preview-2025-03-11:completions",
+    "openai/gpt-5",
+    "openai/gpt-5:completions",
+    "openai/gpt-5:responses",
+    "openai/gpt-5-2025-08-07",
+    "openai/gpt-5-2025-08-07:completions",
+    "openai/gpt-5-2025-08-07:responses",
+    "openai/gpt-5-chat-latest",
+    "openai/gpt-5-chat-latest:completions",
+    "openai/gpt-5-chat-latest:responses",
+    "openai/gpt-5-codex",
+    "openai/gpt-5-codex:responses",
+    "openai/gpt-5-mini",
+    "openai/gpt-5-mini:completions",
+    "openai/gpt-5-mini:responses",
+    "openai/gpt-5-mini-2025-08-07",
+    "openai/gpt-5-mini-2025-08-07:completions",
+    "openai/gpt-5-mini-2025-08-07:responses",
+    "openai/gpt-5-nano",
+    "openai/gpt-5-nano:completions",
+    "openai/gpt-5-nano:responses",
+    "openai/gpt-5-nano-2025-08-07",
+    "openai/gpt-5-nano-2025-08-07:completions",
+    "openai/gpt-5-nano-2025-08-07:responses",
+    "openai/gpt-5-pro",
+    "openai/gpt-5-pro:responses",
+    "openai/gpt-5-pro-2025-10-06",
+    "openai/gpt-5-pro-2025-10-06:responses",
+    "openai/gpt-5-search-api",
+    "openai/gpt-5-search-api:completions",
+    "openai/gpt-5-search-api-2025-10-14",
+    "openai/gpt-5-search-api-2025-10-14:completions",
+    "openai/gpt-5.1",
+    "openai/gpt-5.1:responses",
+    "openai/gpt-5.1-2025-11-13",
+    "openai/gpt-5.1-2025-11-13:responses",
+    "openai/gpt-5.1-chat-latest",
+    "openai/gpt-5.1-chat-latest:completions",
+    "openai/gpt-5.1-chat-latest:responses",
+    "openai/gpt-5.1-codex",
+    "openai/gpt-5.1-codex:responses",
+    "openai/gpt-5.1-codex-max",
+    "openai/gpt-5.1-codex-max:responses",
+    "openai/gpt-5.1-codex-mini",
+    "openai/gpt-5.1-codex-mini:responses",
+    "openai/o1",
+    "openai/o1:completions",
+    "openai/o1:responses",
+    "openai/o1-2024-12-17",
+    "openai/o1-2024-12-17:completions",
+    "openai/o1-2024-12-17:responses",
+    "openai/o1-pro",
+    "openai/o1-pro:responses",
+    "openai/o1-pro-2025-03-19",
+    "openai/o1-pro-2025-03-19:responses",
+    "openai/o3",
+    "openai/o3:completions",
+    "openai/o3:responses",
+    "openai/o3-2025-04-16",
+    "openai/o3-2025-04-16:completions",
+    "openai/o3-2025-04-16:responses",
+    "openai/o3-mini",
+    "openai/o3-mini:completions",
+    "openai/o3-mini:responses",
+    "openai/o3-mini-2025-01-31",
+    "openai/o3-mini-2025-01-31:completions",
+    "openai/o3-mini-2025-01-31:responses",
+    "openai/o3-pro",
+    "openai/o3-pro:responses",
+    "openai/o3-pro-2025-06-10",
+    "openai/o3-pro-2025-06-10:responses",
+    "openai/o4-mini",
+    "openai/o4-mini:completions",
+    "openai/o4-mini:responses",
+    "openai/o4-mini-2025-04-16",
+    "openai/o4-mini-2025-04-16:completions",
+    "openai/o4-mini-2025-04-16:responses",
+]
+"""Valid OpenAI model IDs including API-specific variants."""
+
+
+MODELS_WITHOUT_AUDIO_SUPPORT: set[str] = {
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-0125",
+    "gpt-3.5-turbo-1106",
+    "gpt-4",
+    "gpt-4-0125-preview",
+    "gpt-4-0613",
+    "gpt-4-1106-preview",
+    "gpt-4-turbo",
+    "gpt-4-turbo-2024-04-09",
+    "gpt-4-turbo-preview",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4.1-nano-2025-04-14",
+    "gpt-4o",
+    "gpt-4o-2024-05-13",
+    "gpt-4o-2024-08-06",
+    "gpt-4o-mini",
+    "gpt-4o-mini-2024-07-18",
+    "gpt-4o-mini-search-preview",
+    "gpt-4o-search-preview",
+    "gpt-4o-search-preview-2025-03-11",
+    "gpt-5",
+    "gpt-5-2025-08-07",
+    "gpt-5-chat-latest",
+    "gpt-5-mini",
+    "gpt-5-mini-2025-08-07",
+    "gpt-5-nano",
+    "gpt-5-nano-2025-08-07",
+    "gpt-5-search-api",
+    "gpt-5-search-api-2025-10-14",
+    "gpt-5.1-chat-latest",
+    "o1",
+    "o1-2024-12-17",
+    "o3",
+    "o3-2025-04-16",
+    "o3-mini",
+    "o3-mini-2025-01-31",
+    "o4-mini",
+    "o4-mini-2025-04-16",
+}
+"""Models that do not support audio inputs.
+
+Models not in this set are assumed to support audio (optimistic default).
+"""
+
+NON_REASONING_MODELS: set[str] = {
+    "chatgpt-4o-latest",
+    "gpt-3.5-turbo",
+    "gpt-3.5-turbo-0125",
+    "gpt-3.5-turbo-1106",
+    "gpt-4",
+    "gpt-4-0125-preview",
+    "gpt-4-0613",
+    "gpt-4-1106-preview",
+    "gpt-4-turbo",
+    "gpt-4-turbo-2024-04-09",
+    "gpt-4-turbo-preview",
+    "gpt-4.1",
+    "gpt-4.1-2025-04-14",
+    "gpt-4.1-mini",
+    "gpt-4.1-mini-2025-04-14",
+    "gpt-4.1-nano",
+    "gpt-4.1-nano-2025-04-14",
+    "gpt-4o",
+    "gpt-4o-2024-05-13",
+    "gpt-4o-2024-08-06",
+    "gpt-4o-2024-11-20",
+    "gpt-4o-mini",
+    "gpt-4o-mini-2024-07-18",
+    "gpt-5-chat-latest",
+}
+"""Models that do not support the reasoning parameter.
+
+Models not in this set are assumed to support reasoning (optimistic default).
+"""

mirascope/llm/providers/openai/provider.py

@@ -0,0 +1,386 @@
+"""Unified OpenAI client implementation."""
+
+from collections.abc import Sequence
+from typing_extensions import Unpack
+
+from openai import OpenAI
+
+from ...context import Context, DepsT
+from ...formatting import Format, FormattableT
+from ...messages import Message
+from ...responses import (
+    AsyncContextResponse,
+    AsyncContextStreamResponse,
+    AsyncResponse,
+    AsyncStreamResponse,
+    ContextResponse,
+    ContextStreamResponse,
+    Response,
+    StreamResponse,
+)
+from ...tools import (
+    AsyncContextTool,
+    AsyncContextToolkit,
+    AsyncTool,
+    AsyncToolkit,
+    ContextTool,
+    ContextToolkit,
+    Tool,
+    Toolkit,
+)
+from ..base import BaseProvider, Params
+from .completions import OpenAICompletionsProvider
+from .model_id import OPENAI_KNOWN_MODELS, OpenAIModelId
+from .responses import OpenAIResponsesProvider
+
+
+def _has_audio_content(messages: Sequence[Message]) -> bool:
+    """Returns whether a sequence of messages contains any audio content."""
+    for message in messages:
+        if message.role == "system":
+            continue
+        for content in message.content:
+            if content.type == "audio":
+                return True
+    return False
+
+
+def choose_api_mode(model_id: OpenAIModelId, messages: Sequence[Message]) -> str:
+    """Choose between 'responses' or 'completions' API based on model_id and messages.
+
+    Args:
+        model_id: The model identifier.
+        messages: The messages to send to the LLM.
+
+    Returns:
+        Either "responses" or "completions" depending on the model and message content.
+
+    If the user manually specified an api mode (by appending it as a suffix to the model
+    id), then we use it.
+
+    Otherwise, we prefer the responses API where supported (because it has better
+    reasoning support and better prompt caching). However we will use the :completions api
+    if the messages contain any audio content, as audio content is not yet supported in
+    the responses API.
+    """
+    if model_id.endswith(":completions"):
+        return "completions"
+    elif model_id.endswith(":responses"):
+        return "responses"
+
+    if _has_audio_content(messages):
+        return "completions"
+
+    if f"{model_id}:responses" in OPENAI_KNOWN_MODELS:
+        # Prefer responses api when we know it is available
+        return "responses"
+    elif f"{model_id}:completions" in OPENAI_KNOWN_MODELS:
+        # If we know from testing that the completions api is available, and
+        # (implied by above) that responses wasn't, then we should use completions
+        return "completions"
+
+    # If we don't have either :responses or :completions in the known_models, it's
+    # likely that this is a new model we haven't tested. We default to responses api for
+    # openai/ models (on the assumption that they are new models and OpenAI prefers
+    # the responses API) but completions for other models (on the assumption that they
+    # are other models routing through the OpenAI completions API)
+    if model_id.startswith("openai/"):
+        return "responses"
+    else:
+        return "completions"
+
+
+class OpenAIProvider(BaseProvider[OpenAI]):
+    """Unified provider for OpenAI that routes to Completions or Responses API based on model_id."""
+
+    id = "openai"
+    default_scope = "openai/"
+
+    def __init__(
+        self, *, api_key: str | None = None, base_url: str | None = None
+    ) -> None:
+        """Initialize the OpenAI provider with both subclients."""
+        self._completions_provider = OpenAICompletionsProvider(
+            api_key=api_key, base_url=base_url, wrapped_by_openai_provider=True
+        )
+        self._responses_provider = OpenAIResponsesProvider(
+            api_key=api_key, base_url=base_url, wrapped_by_openai_provider=True
+        )
+        # Use completions client's underlying OpenAI client as the main one
+        self.client = self._completions_provider.client
+
+    def _choose_subprovider(
+        self, model_id: OpenAIModelId, messages: Sequence[Message]
+    ) -> OpenAICompletionsProvider | OpenAIResponsesProvider:
+        """Choose the appropriate provider based on model_id and messages.
+
+        Args:
+            model_id: The model identifier.
+            messages: The messages to send to the LLM.
+
+        Returns:
+            The responses or completions subclient.
+        """
+        api_mode = choose_api_mode(model_id, messages)
+        if api_mode == "responses":
+            return self._responses_provider
+        return self._completions_provider
+
+    def _call(
+        self,
+        *,
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[Tool] | Toolkit | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> Response | Response[FormattableT]:
+        """Generate an `llm.Response` by synchronously calling the OpenAI API.
+
+        Args:
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.Response` object containing the LLM-generated content.
+        """
+        client = self._choose_subprovider(model_id, messages)
+        return client.call(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    def _context_call(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[Tool | ContextTool[DepsT]]
+        | ContextToolkit[DepsT]
+        | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> ContextResponse[DepsT, None] | ContextResponse[DepsT, FormattableT]:
+        """Generate an `llm.ContextResponse` by synchronously calling the OpenAI API.
+
+        Args:
+            ctx: Context object with dependencies for tools.
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.ContextResponse` object containing the LLM-generated content.
+        """
+        client = self._choose_subprovider(model_id, messages)
+        return client.context_call(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _call_async(
+        self,
+        *,
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> AsyncResponse | AsyncResponse[FormattableT]:
+        """Generate an `llm.AsyncResponse` by asynchronously calling the OpenAI API.
+
+        Args:
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.AsyncResponse` object containing the LLM-generated content.
+        """
+        return await self._choose_subprovider(model_id, messages).call_async(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _context_call_async(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
+        | AsyncContextToolkit[DepsT]
+        | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> AsyncContextResponse[DepsT, None] | AsyncContextResponse[DepsT, FormattableT]:
+        """Generate an `llm.AsyncContextResponse` by asynchronously calling the OpenAI API.
+
+        Args:
+            ctx: Context object with dependencies for tools.
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.AsyncContextResponse` object containing the LLM-generated content.
+        """
+        return await self._choose_subprovider(model_id, messages).context_call_async(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    def _stream(
+        self,
+        *,
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[Tool] | Toolkit | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> StreamResponse | StreamResponse[FormattableT]:
+        """Generate an `llm.StreamResponse` by synchronously streaming from the OpenAI API.
+
+        Args:
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.StreamResponse` object for iterating over the LLM-generated content.
+        """
+        client = self._choose_subprovider(model_id, messages)
+        return client.stream(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    def _context_stream(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[Tool | ContextTool[DepsT]]
+        | ContextToolkit[DepsT]
+        | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> ContextStreamResponse[DepsT] | ContextStreamResponse[DepsT, FormattableT]:
+        """Generate an `llm.ContextStreamResponse` by synchronously streaming from the OpenAI API.
+
+        Args:
+            ctx: Context object with dependencies for tools.
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.ContextStreamResponse` object for iterating over the LLM-generated content.
+        """
+        client = self._choose_subprovider(model_id, messages)
+        return client.context_stream(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _stream_async(
+        self,
+        *,
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
+        """Generate an `llm.AsyncStreamResponse` by asynchronously streaming from the OpenAI API.
+
+        Args:
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.AsyncStreamResponse` object for asynchronously iterating over the LLM-generated content.
+        """
+        return await self._choose_subprovider(model_id, messages).stream_async(
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )
+
+    async def _context_stream_async(
+        self,
+        *,
+        ctx: Context[DepsT],
+        model_id: OpenAIModelId,
+        messages: Sequence[Message],
+        tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
+        | AsyncContextToolkit[DepsT]
+        | None = None,
+        format: type[FormattableT] | Format[FormattableT] | None = None,
+        **params: Unpack[Params],
+    ) -> (
+        AsyncContextStreamResponse[DepsT]
+        | AsyncContextStreamResponse[DepsT, FormattableT]
+    ):
+        """Generate an `llm.AsyncContextStreamResponse` by asynchronously streaming from the OpenAI API.
+
+        Args:
+            ctx: Context object with dependencies for tools.
+            model_id: Model identifier to use.
+            messages: Messages to send to the LLM.
+            tools: Optional tools that the model may invoke.
+            format: Optional response format specifier.
+            **params: Additional parameters to configure output (e.g. temperature). See `llm.Params`.
+
+        Returns:
+            An `llm.AsyncContextStreamResponse` object for asynchronously iterating over the LLM-generated content.
+        """
+        return await self._choose_subprovider(model_id, messages).context_stream_async(
+            ctx=ctx,
+            model_id=model_id,
+            messages=messages,
+            tools=tools,
+            format=format,
+            **params,
+        )

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

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

mirascope/llm/{clients → providers}/openai/responses/_utils/decode.py

@@ -30,7 +30,7 @@ from .....responses import (
     RawMessageChunk,
     RawStreamEventChunk,
 )
-from ..model_ids import OpenAIResponsesModelId
+from ...model_id import OpenAIModelId, model_name
 
 INCOMPLETE_DETAILS_TO_FINISH_REASON = {
     "max_output_tokens": FinishReason.MAX_TOKENS,
@@ -47,7 +47,8 @@ def _serialize_output_item(
 
 def decode_response(
     response: openai_types.Response,
-    model_id: OpenAIResponsesModelId,
+    model_id: OpenAIModelId,
+    provider_id: Literal["openai", "openai:responses"],
 ) -> tuple[AssistantMessage, FinishReason | None]:
     """Convert OpenAI Responses Response to mirascope AssistantMessage."""
     parts: list[AssistantContentPart] = []
@@ -91,8 +92,9 @@ def decode_response(
 
     assistant_message = AssistantMessage(
         content=parts,
-        provider="openai:responses",
+        provider_id=provider_id,
         model_id=model_id,
+        provider_model_name=model_name(model_id, "responses"),
         raw_message=[
             _serialize_output_item(output_item) for output_item in response.output
         ],