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

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/__init__.py

@@ -1,23 +1,5 @@
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .base_provider import BaseOpenAICompletionsProvider
-    from .provider import OpenAICompletionsProvider
-else:
-    try:
-        from .base_provider import BaseOpenAICompletionsProvider
-        from .provider import OpenAICompletionsProvider
-    except ImportError:  # pragma: no cover
-        from ..._missing_import_stubs import (
-            create_provider_stub,
-        )
-
-        BaseOpenAICompletionsProvider = create_provider_stub(
-            "openai", "BaseOpenAICompletionsProvider"
-        )
-        OpenAICompletionsProvider = create_provider_stub(
-            "openai", "OpenAICompletionsProvider"
-        )
+from .base_provider import BaseOpenAICompletionsProvider
+from .provider import OpenAICompletionsProvider
 
 __all__ = [
     "BaseOpenAICompletionsProvider",

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

@@ -117,6 +117,7 @@ class _OpenAIChunkProcessor:
     def __init__(self) -> None:
         self.current_content_type: Literal["text", "tool_call"] | None = None
         self.current_tool_index: int | None = None
+        self.current_tool_id: str | None = None
         self.refusal_encountered = False
 
     def process_chunk(self, chunk: openai_types.ChatCompletionChunk) -> ChunkIterator:
@@ -180,7 +181,9 @@ class _OpenAIChunkProcessor:
                     self.current_tool_index is not None
                     and self.current_tool_index < index
                 ):
-                    yield ToolCallEndChunk()
+                    if self.current_tool_id is None:  # pragma: no cover
+                        raise RuntimeError("No current_tool_id for ToolCallChunk")
+                    yield ToolCallEndChunk(id=self.current_tool_id)
                     self.current_tool_index = None
 
                 if self.current_tool_index is None:
@@ -201,15 +204,23 @@ class _OpenAIChunkProcessor:
                         id=tool_id,
                         name=name,
                     )
+                    self.current_tool_id = tool_id
 
                 if tool_call_delta.function and tool_call_delta.function.arguments:
-                    yield ToolCallChunk(delta=tool_call_delta.function.arguments)
+                    if self.current_tool_id is None:  # pragma: no cover
+                        raise RuntimeError("No current_tool_id for ToolCallChunk")
+                    yield ToolCallChunk(
+                        id=self.current_tool_id,
+                        delta=tool_call_delta.function.arguments,
+                    )
 
         if choice.finish_reason:
             if self.current_content_type == "text":
                 yield TextEndChunk()
             elif self.current_content_type == "tool_call":
-                yield ToolCallEndChunk()
+                if self.current_tool_id is None:  # pragma: no cover
+                    raise RuntimeError("No current_tool_id for ToolCallChunk")
+                yield ToolCallEndChunk(id=self.current_tool_id)
             elif self.current_content_type is not None:  # pragma: no cover
                 raise NotImplementedError()
 

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

@@ -1,26 +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,
-    _utils as _formatting_utils,
-    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,
@@ -28,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."""
@@ -130,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,
                 )
             )
@@ -144,7 +141,7 @@ def _encode_user_message(
 
 
 def _encode_assistant_message(
-    message: AssistantMessage, model_id: OpenAIModelId, encode_thoughts: bool
+    message: AssistantMessage, model_id: OpenAIModelId, encode_thoughts_as_text: bool
 ) -> openai_types.ChatCompletionAssistantMessageParam:
     """Convert Mirascope `AssistantMessage` to OpenAI `ChatCompletionAssistantMessageParam`."""
 
@@ -153,7 +150,7 @@ def _encode_assistant_message(
         and message.provider_model_name
         == model_name(model_id=model_id, api_mode="completions")
         and message.raw_message
-        and not encode_thoughts
+        and not encode_thoughts_as_text
     ):
         return cast(
             openai_types.ChatCompletionAssistantMessageParam, message.raw_message
@@ -177,7 +174,7 @@ def _encode_assistant_message(
                 )
             )
         elif part.type == "thought":
-            if encode_thoughts:
+            if encode_thoughts_as_text:
                 text_params.append(
                     openai_types.ChatCompletionContentPartTextParam(
                         text="**Thinking:** " + part.thought, type="text"
@@ -203,7 +200,7 @@ def _encode_assistant_message(
 
 
 def _encode_message(
-    message: Message, model_id: OpenAIModelId, encode_thoughts: bool
+    message: Message, model_id: OpenAIModelId, encode_thoughts_as_text: bool
 ) -> list[openai_types.ChatCompletionMessageParam]:
     """Convert a Mirascope `Message` to OpenAI `ChatCompletionMessageParam` format.
 
@@ -224,7 +221,7 @@ def _encode_message(
     elif message.role == "user":
         return _encode_user_message(message, model_id)
     elif message.role == "assistant":
-        return [_encode_assistant_message(message, model_id, encode_thoughts)]
+        return [_encode_assistant_message(message, model_id, encode_thoughts_as_text)]
     else:
         raise ValueError(f"Unsupported role: {message.role}")  # pragma: no cover
 
@@ -237,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,
         },
     )
 
@@ -281,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."""
@@ -299,12 +302,12 @@ def encode_request(
             "model": base_model_name,
         }
     )
-    encode_thoughts = False
+    encode_thoughts_as_text = False
 
     with _base_utils.ensure_all_params_accessed(
         params=params,
         provider_id="openai",
-        unsupported_params=["top_k", "thinking"],
+        unsupported_params=["top_k"],
     ) as param_accessor:
         if param_accessor.temperature is not None:
             kwargs["temperature"] = param_accessor.temperature
@@ -317,8 +320,10 @@ def encode_request(
             kwargs["seed"] = param_accessor.seed
         if param_accessor.stop_sequences is not None:
             kwargs["stop"] = param_accessor.stop_sequences
-        if param_accessor.encode_thoughts_as_text is not None:
-            encode_thoughts = True
+        if param_accessor.thinking is not None:
+            thinking = param_accessor.thinking
+            if thinking.get("encode_thoughts_as_text"):
+                encode_thoughts_as_text = True
 
     tools = tools.tools if isinstance(tools, BaseToolkit) else tools or []
 
@@ -330,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,
                 )
@@ -345,7 +350,7 @@ def encode_request(
                     "function": {"name": FORMAT_TOOL_NAME},
                 }
                 kwargs["parallel_tool_calls"] = False
-            format_tool_schema = _formatting_utils.create_tool_schema(format)
+            format_tool_schema = format.create_tool_schema()
             openai_tools.append(_convert_tool_to_tool_param(format_tool_schema))
         elif (
             format.mode == "json"
@@ -363,7 +368,9 @@ def encode_request(
 
     encoded_messages: list[openai_types.ChatCompletionMessageParam] = []
     for message in messages:
-        encoded_messages.extend(_encode_message(message, model_id, encode_thoughts))
+        encoded_messages.extend(
+            _encode_message(message, model_id, encode_thoughts_as_text)
+        )
     kwargs["messages"] = encoded_messages
 
     return messages, format, kwargs

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/__init__.py

@@ -1,20 +1,4 @@
-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"
-        )
-
+from .provider import OpenAIResponsesProvider
 
 __all__ = [
     "OpenAIResponsesProvider",

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."""
@@ -173,23 +179,26 @@ class _OpenAIResponsesChunkProcessor:
                     )
                     self.current_content_type = "tool_call"
             elif event.type == "response.function_call_arguments.delta":
-                yield ToolCallChunk(delta=event.delta)
+                yield ToolCallChunk(id=self.current_tool_call_id, delta=event.delta)
             elif event.type == "response.function_call_arguments.done":
-                yield ToolCallEndChunk()
+                yield ToolCallEndChunk(id=self.current_tool_call_id)
                 self.current_content_type = None
             elif (
                 event.type == "response.reasoning_text.delta"
                 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