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

mirascope/llm/providers/mlx/provider.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from collections.abc import Sequence
 from functools import cache, lru_cache
-from typing import cast
+from typing import TYPE_CHECKING, cast
 from typing_extensions import Unpack
 
 import mlx.nn as nn
@@ -8,7 +10,7 @@ from mlx_lm import load as mlx_load
 from transformers import PreTrainedTokenizer
 
 from ...context import Context, DepsT
-from ...formatting import Format, FormattableT
+from ...formatting import Format, FormattableT, OutputParser
 from ...messages import Message
 from ...responses import (
     AsyncContextResponse,
@@ -30,20 +32,23 @@ from ...tools import (
     Tool,
     Toolkit,
 )
-from ..base import BaseProvider, Params
+from ..base import BaseProvider
 from . import _utils
 from .encoding import TransformersEncoder
 from .mlx import MLX
 from .model_id import MLXModelId
 
+if TYPE_CHECKING:
+    from ...models import Params
+
 
 @cache
-def _mlx_client_singleton() -> "MLXProvider":
+def _mlx_client_singleton() -> MLXProvider:
     """Get or create the singleton MLX client instance."""
     return MLXProvider()
 
 
-def client() -> "MLXProvider":
+def client() -> MLXProvider:
     """Get the MLX client singleton instance."""
     return _mlx_client_singleton()
 
@@ -85,7 +90,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         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` using MLX model.
@@ -129,7 +137,10 @@ class MLXProvider(BaseProvider[None]):
         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, None] | ContextResponse[DepsT, FormattableT]:
         """Generate an `llm.ContextResponse` using MLX model.
@@ -171,7 +182,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         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` using MLX model by asynchronously calloing
@@ -219,7 +233,10 @@ class MLXProvider(BaseProvider[None]):
         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, None] | AsyncContextResponse[DepsT, FormattableT]:
         """Generate an `llm.AsyncResponse` using MLX model by asynchronously calloing
@@ -265,7 +282,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         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 an `llm.StreamResponse` by synchronously streaming from MLX model output.
@@ -306,7 +326,10 @@ class MLXProvider(BaseProvider[None]):
         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 an `llm.ContextStreamResponse` by synchronously streaming from MLX model output.
@@ -345,7 +368,10 @@ class MLXProvider(BaseProvider[None]):
         model_id: MLXModelId,
         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 an `llm.AsyncStreamResponse` by asynchronously streaming from MLX model output.
@@ -386,7 +412,10 @@ class MLXProvider(BaseProvider[None]):
         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]

mirascope/llm/providers/openai/_utils/errors.py

@@ -16,12 +16,12 @@ from openai import (
 )
 
 from ....exceptions import (
-    APIError,
     AuthenticationError,
     BadRequestError,
     ConnectionError,
     NotFoundError,
     PermissionError,
+    ProviderError,
     RateLimitError,
     ResponseValidationError,
     ServerError,
@@ -42,5 +42,5 @@ OPENAI_ERROR_MAP: ProviderErrorMap = {
     OpenAIAPITimeoutError: TimeoutError,
     OpenAIAPIConnectionError: ConnectionError,
     OpenAIAPIResponseValidationError: ResponseValidationError,
-    OpenAIError: APIError,  # Catch-all for unknown OpenAI errors
+    OpenAIError: ProviderError,  # Catch-all for unknown OpenAI errors
 }

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

@@ -1,25 +1,20 @@
 """OpenAI completions message encoding and request preparation."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
 from functools import lru_cache
-from typing import TypedDict, cast
+from typing import TYPE_CHECKING, TypedDict, cast
 
 from openai import Omit
 from openai.types import chat as openai_types, shared_params as shared_openai_types
 from openai.types.shared_params.response_format_json_schema import JSONSchema
 
-from .....exceptions import (
-    FeatureNotSupportedError,
-    FormattingModeNotSupportedError,
-)
-from .....formatting import (
-    Format,
-    FormattableT,
-    resolve_format,
-)
+from .....exceptions import FeatureNotSupportedError
+from .....formatting import Format, FormattableT, 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_AUDIO_SUPPORT,
@@ -27,6 +22,9 @@ from ...model_info import (
     MODELS_WITHOUT_JSON_SCHEMA_SUPPORT,
 )
 
+if TYPE_CHECKING:
+    from .....models import Params
+
 
 class ChatCompletionCreateKwargs(TypedDict, total=False):
     """Kwargs for OpenAI ChatCompletion.create method."""
@@ -129,7 +127,7 @@ def _encode_user_message(
             result.append(
                 openai_types.ChatCompletionToolMessageParam(
                     role="tool",
-                    content=str(part.value),
+                    content=str(part.result),
                     tool_call_id=part.id,
                 )
             )
@@ -236,13 +234,16 @@ def _convert_tool_to_tool_param(
     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 openai_types.ChatCompletionToolParam(
         type="function",
         function={
             "name": tool.name,
             "description": tool.description,
             "parameters": schema_dict,
-            "strict": tool.strict,
+            "strict": strict,
         },
     )
 
@@ -280,7 +281,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, ChatCompletionCreateKwargs]:
     """Prepares a request for the `OpenAI.chat.completions.create` method."""
@@ -331,8 +335,8 @@ def encode_request(
     if format is not None:
         if format.mode == "strict":
             if not model_supports_strict:
-                raise FormattingModeNotSupportedError(
-                    formatting_mode="strict",
+                raise FeatureNotSupportedError(
+                    feature="formatting_mode:strict",
                     provider_id="openai",
                     model_id=model_id,
                 )

mirascope/llm/providers/openai/completions/base_provider.py

@@ -1,14 +1,16 @@
 """Base class for OpenAI Completions-compatible providers."""
 
+from __future__ import annotations
+
 import os
 from collections.abc import Sequence
-from typing import ClassVar
+from typing import TYPE_CHECKING, ClassVar
 from typing_extensions import Unpack
 
 from openai import AsyncOpenAI, OpenAI
 
 from ....context import Context, DepsT
-from ....formatting import Format, FormattableT
+from ....formatting import Format, FormattableT, OutputParser
 from ....messages import Message
 from ....responses import (
     AsyncContextResponse,
@@ -30,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 model_name as openai_model_name
 from . import _utils
 
+if TYPE_CHECKING:
+    from ....models import Params
+
 
 class BaseOpenAICompletionsProvider(BaseProvider[OpenAI]):
     """Base class for providers that use OpenAI Completions-compatible APIs."""
@@ -97,7 +102,10 @@ class BaseOpenAICompletionsProvider(BaseProvider[OpenAI]):
         model_id: str,
         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 API.
@@ -152,7 +160,10 @@ class BaseOpenAICompletionsProvider(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, None] | ContextResponse[DepsT, FormattableT]:
         """Generate an `llm.ContextResponse` by synchronously calling the API.
@@ -205,7 +216,10 @@ class BaseOpenAICompletionsProvider(BaseProvider[OpenAI]):
         model_id: str,
         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 API.
@@ -260,7 +274,10 @@ class BaseOpenAICompletionsProvider(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, None] | AsyncContextResponse[DepsT, FormattableT]:
         """Generate an `llm.AsyncContextResponse` by asynchronously calling the API.
@@ -313,7 +330,10 @@ class BaseOpenAICompletionsProvider(BaseProvider[OpenAI]):
         model_id: str,
         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 an `llm.StreamResponse` by synchronously streaming from the API.
@@ -364,7 +384,10 @@ class BaseOpenAICompletionsProvider(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 an `llm.ContextStreamResponse` by synchronously streaming from the API.
@@ -414,7 +437,10 @@ class BaseOpenAICompletionsProvider(BaseProvider[OpenAI]):
         model_id: str,
         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 an `llm.AsyncStreamResponse` by asynchronously streaming from the API.
@@ -465,7 +491,10 @@ class BaseOpenAICompletionsProvider(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]

mirascope/llm/providers/openai/provider.py

@@ -1,13 +1,16 @@
 """Unified OpenAI client implementation."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
+from typing import TYPE_CHECKING
 from typing_extensions import Unpack
 
 from openai import 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,12 +32,15 @@ from ...tools import (
     Tool,
     Toolkit,
 )
-from ..base import BaseProvider, Params
+from ..base import BaseProvider
 from . import _utils
 from .completions import OpenAICompletionsProvider
 from .model_id import OPENAI_KNOWN_MODELS, OpenAIModelId
 from .responses import OpenAIResponsesProvider
 
+if TYPE_CHECKING:
+    from ...models import Params
+
 
 def _has_audio_content(messages: Sequence[Message]) -> bool:
     """Returns whether a sequence of messages contains any audio content."""
@@ -157,7 +163,10 @@ class OpenAIProvider(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 API.
@@ -190,7 +199,10 @@ class OpenAIProvider(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, None] | ContextResponse[DepsT, FormattableT]:
         """Generate an `llm.ContextResponse` by synchronously calling the OpenAI API.
@@ -222,7 +234,10 @@ class OpenAIProvider(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 API.
@@ -254,7 +269,10 @@ class OpenAIProvider(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, None] | AsyncContextResponse[DepsT, FormattableT]:
         """Generate an `llm.AsyncContextResponse` by asynchronously calling the OpenAI API.
@@ -285,7 +303,10 @@ class OpenAIProvider(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 an `llm.StreamResponse` by synchronously streaming from the OpenAI API.
@@ -318,7 +339,10 @@ class OpenAIProvider(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 an `llm.ContextStreamResponse` by synchronously streaming from the OpenAI API.
@@ -350,7 +374,10 @@ class OpenAIProvider(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 an `llm.AsyncStreamResponse` by asynchronously streaming from the OpenAI API.
@@ -382,7 +409,10 @@ class OpenAIProvider(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]

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

@@ -1,3 +1,4 @@
+from ....base._utils import get_include_thoughts
 from .decode import (
     decode_async_stream,
     decode_response,
@@ -10,4 +11,5 @@ __all__ = [
     "decode_response",
     "decode_stream",
     "encode_request",
+    "get_include_thoughts",
 ]

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

@@ -78,6 +78,8 @@ def decode_response(
     response: openai_types.Response,
     model_id: OpenAIModelId,
     provider_id: str,
+    *,
+    include_thoughts: bool,
 ) -> tuple[AssistantMessage, FinishReason | None, Usage | None]:
     """Convert OpenAI Responses Response to mirascope AssistantMessage and usage."""
     parts: list[AssistantContentPart] = []
@@ -114,6 +116,9 @@ def decode_response(
         else:
             raise NotImplementedError(f"Unsupported output item: {output_item.type}")
 
+    if not include_thoughts:
+        parts = [part for part in parts if part.type != "thought"]
+
     if refused:
         finish_reason = FinishReason.REFUSAL
     elif details := response.incomplete_details:
@@ -136,9 +141,10 @@ def decode_response(
 class _OpenAIResponsesChunkProcessor:
     """Processes OpenAI Responses streaming events and maintains state across chunks."""
 
-    def __init__(self) -> None:
+    def __init__(self, *, include_thoughts: bool) -> None:
         self.current_content_type: Literal["text", "tool_call", "thought"] | None = None
         self.refusal_encountered = False
+        self.include_thoughts = include_thoughts
 
     def process_chunk(self, event: ResponseStreamEvent) -> ChunkIterator:
         """Process a single OpenAI Responses stream event and yield the appropriate content chunks."""
@@ -182,14 +188,17 @@ class _OpenAIResponsesChunkProcessor:
                 or event.type == "response.reasoning_summary_text.delta"
             ):
                 if not self.current_content_type:
-                    yield ThoughtStartChunk()
+                    if self.include_thoughts:
+                        yield ThoughtStartChunk()
                     self.current_content_type = "thought"
-                yield ThoughtChunk(delta=event.delta)
+                if self.include_thoughts:
+                    yield ThoughtChunk(delta=event.delta)
             elif (
                 event.type == "response.reasoning_summary_text.done"
                 or event.type == "response.reasoning_text.done"
             ):
-                yield ThoughtEndChunk()
+                if self.include_thoughts:
+                    yield ThoughtEndChunk()
                 self.current_content_type = None
             elif event.type == "response.incomplete":
                 details = event.response.incomplete_details
@@ -230,18 +239,22 @@ class _OpenAIResponsesChunkProcessor:
 
 def decode_stream(
     openai_stream: Stream[ResponseStreamEvent],
+    *,
+    include_thoughts: bool,
 ) -> ChunkIterator:
     """Returns a ChunkIterator converted from an OpenAI Stream[ResponseStreamEvent]"""
-    processor = _OpenAIResponsesChunkProcessor()
+    processor = _OpenAIResponsesChunkProcessor(include_thoughts=include_thoughts)
     for event in openai_stream:
         yield from processor.process_chunk(event)
 
 
 async def decode_async_stream(
     openai_stream: AsyncStream[ResponseStreamEvent],
+    *,
+    include_thoughts: bool,
 ) -> AsyncChunkIterator:
     """Returns an AsyncChunkIterator converted from an OpenAI AsyncStream[ResponseStreamEvent]"""
-    processor = _OpenAIResponsesChunkProcessor()
+    processor = _OpenAIResponsesChunkProcessor(include_thoughts=include_thoughts)
     async for event in openai_stream:
         for item in processor.process_chunk(event):
             yield item