openai-agents 0.2.8__py3-none-any.whl → 0.6.8__py3-none-any.whl

agents/models/chatcmpl_stream_handler.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
+from typing import Any
 
 from openai import AsyncStream
 from openai.types.chat import ChatCompletionChunk
@@ -28,14 +29,21 @@ from openai.types.responses import (
     ResponseTextDeltaEvent,
     ResponseUsage,
 )
-from openai.types.responses.response_reasoning_item import Summary
+from openai.types.responses.response_reasoning_item import Content, Summary
 from openai.types.responses.response_reasoning_summary_part_added_event import (
     Part as AddedEventPart,
 )
 from openai.types.responses.response_reasoning_summary_part_done_event import Part as DoneEventPart
+from openai.types.responses.response_reasoning_text_delta_event import (
+    ResponseReasoningTextDeltaEvent,
+)
+from openai.types.responses.response_reasoning_text_done_event import (
+    ResponseReasoningTextDoneEvent,
+)
 from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
 
 from ..items import TResponseStreamEvent
+from .chatcmpl_helpers import ChatCmplHelpers
 from .fake_id import FAKE_RESPONSES_ID
 
 
@@ -56,6 +64,11 @@ class StreamingState:
     # Fields for real-time function call streaming
     function_call_streaming: dict[int, bool] = field(default_factory=dict)
     function_call_output_idx: dict[int, int] = field(default_factory=dict)
+    # Store accumulated thinking text and signature for Anthropic compatibility
+    thinking_text: str = ""
+    thinking_signature: str | None = None
+    # Store provider data for all output items
+    provider_data: dict[str, Any] = field(default_factory=dict)
 
 
 class SequenceNumber:
@@ -74,7 +87,17 @@ class ChatCmplStreamHandler:
         cls,
         response: Response,
         stream: AsyncStream[ChatCompletionChunk],
+        model: str | None = None,
     ) -> AsyncIterator[TResponseStreamEvent]:
+        """
+        Handle a streaming chat completion response and yield response events.
+
+        Args:
+            response: The initial Response object to populate with streamed data
+            stream: The async stream of chat completion chunks from the model
+            model: The source model that is generating this stream. Used to handle
+                provider-specific stream processing.
+        """
         usage: CompletionUsage | None = None
         state = StreamingState()
         sequence_number = SequenceNumber()
@@ -88,31 +111,52 @@ class ChatCmplStreamHandler:
                 )
 
             # This is always set by the OpenAI API, but not by others e.g. LiteLLM
-            usage = chunk.usage if hasattr(chunk, "usage") else None
+            # Only update when chunk has usage data (not always in the last chunk)
+            if hasattr(chunk, "usage") and chunk.usage is not None:
+                usage = chunk.usage
 
             if not chunk.choices or not chunk.choices[0].delta:
                 continue
 
-            delta = chunk.choices[0].delta
+            # Build provider_data for non-OpenAI Responses API endpoints format
+            if model:
+                state.provider_data["model"] = model
+            elif hasattr(chunk, "model") and chunk.model:
+                state.provider_data["model"] = chunk.model
+
+            if hasattr(chunk, "id") and chunk.id:
+                state.provider_data["response_id"] = chunk.id
 
-            # Handle reasoning content
+            delta = chunk.choices[0].delta
+            choice_logprobs = chunk.choices[0].logprobs
+
+            # Handle thinking blocks from Anthropic (for preserving signatures)
+            if hasattr(delta, "thinking_blocks") and delta.thinking_blocks:
+                for block in delta.thinking_blocks:
+                    if isinstance(block, dict):
+                        # Accumulate thinking text
+                        thinking_text = block.get("thinking", "")
+                        if thinking_text:
+                            state.thinking_text += thinking_text
+                        # Store signature if present
+                        signature = block.get("signature")
+                        if signature:
+                            state.thinking_signature = signature
+
+            # Handle reasoning content for reasoning summaries
             if hasattr(delta, "reasoning_content"):
                 reasoning_content = delta.reasoning_content
                 if reasoning_content and not state.reasoning_content_index_and_output:
-                    state.reasoning_content_index_and_output = (
-                        0,
-                        ResponseReasoningItem(
-                            id=FAKE_RESPONSES_ID,
-                            summary=[Summary(text="", type="summary_text")],
-                            type="reasoning",
-                        ),
+                    reasoning_item = ResponseReasoningItem(
+                        id=FAKE_RESPONSES_ID,
+                        summary=[Summary(text="", type="summary_text")],
+                        type="reasoning",
                     )
+                    if state.provider_data:
+                        reasoning_item.provider_data = state.provider_data.copy()  # type: ignore[attr-defined]
+                    state.reasoning_content_index_and_output = (0, reasoning_item)
                     yield ResponseOutputItemAddedEvent(
-                        item=ResponseReasoningItem(
-                            id=FAKE_RESPONSES_ID,
-                            summary=[Summary(text="", type="summary_text")],
-                            type="reasoning",
-                        ),
+                        item=reasoning_item,
                         output_index=0,
                         type="response.output_item.added",
                         sequence_number=sequence_number.get_and_increment(),
@@ -128,6 +172,12 @@ class ChatCmplStreamHandler:
                     )
 
                 if reasoning_content and state.reasoning_content_index_and_output:
+                    # Ensure summary list has at least one element
+                    if not state.reasoning_content_index_and_output[1].summary:
+                        state.reasoning_content_index_and_output[1].summary = [
+                            Summary(text="", type="summary_text")
+                        ]
+
                     yield ResponseReasoningSummaryTextDeltaEvent(
                         delta=reasoning_content,
                         item_id=FAKE_RESPONSES_ID,
@@ -138,10 +188,50 @@ class ChatCmplStreamHandler:
                     )
 
                     # Create a new summary with updated text
-                    current_summary = state.reasoning_content_index_and_output[1].summary[0]
-                    updated_text = current_summary.text + reasoning_content
-                    new_summary = Summary(text=updated_text, type="summary_text")
-                    state.reasoning_content_index_and_output[1].summary[0] = new_summary
+                    current_content = state.reasoning_content_index_and_output[1].summary[0]
+                    updated_text = current_content.text + reasoning_content
+                    new_content = Summary(text=updated_text, type="summary_text")
+                    state.reasoning_content_index_and_output[1].summary[0] = new_content
+
+            # Handle reasoning content from 3rd party platforms
+            if hasattr(delta, "reasoning"):
+                reasoning_text = delta.reasoning
+                if reasoning_text and not state.reasoning_content_index_and_output:
+                    reasoning_item = ResponseReasoningItem(
+                        id=FAKE_RESPONSES_ID,
+                        summary=[],
+                        content=[Content(text="", type="reasoning_text")],
+                        type="reasoning",
+                    )
+                    if state.provider_data:
+                        reasoning_item.provider_data = state.provider_data.copy()  # type: ignore[attr-defined]
+                    state.reasoning_content_index_and_output = (0, reasoning_item)
+                    yield ResponseOutputItemAddedEvent(
+                        item=reasoning_item,
+                        output_index=0,
+                        type="response.output_item.added",
+                        sequence_number=sequence_number.get_and_increment(),
+                    )
+
+                if reasoning_text and state.reasoning_content_index_and_output:
+                    yield ResponseReasoningTextDeltaEvent(
+                        delta=reasoning_text,
+                        item_id=FAKE_RESPONSES_ID,
+                        output_index=0,
+                        content_index=0,
+                        type="response.reasoning_text.delta",
+                        sequence_number=sequence_number.get_and_increment(),
+                    )
+
+                    # Create a new summary with updated text
+                    if not state.reasoning_content_index_and_output[1].content:
+                        state.reasoning_content_index_and_output[1].content = [
+                            Content(text="", type="reasoning_text")
+                        ]
+                    current_text = state.reasoning_content_index_and_output[1].content[0]
+                    updated_text = current_text.text + reasoning_text
+                    new_text_content = Content(text=updated_text, type="reasoning_text")
+                    state.reasoning_content_index_and_output[1].content[0] = new_text_content
 
             # Handle regular content
             if delta.content is not None:
@@ -158,6 +248,7 @@ class ChatCmplStreamHandler:
                             text="",
                             type="output_text",
                             annotations=[],
+                            logprobs=[],
                         ),
                     )
                     # Start a new assistant message stream
@@ -168,6 +259,8 @@ class ChatCmplStreamHandler:
                         type="message",
                         status="in_progress",
                     )
+                    if state.provider_data:
+                        assistant_item.provider_data = state.provider_data.copy()  # type: ignore[attr-defined]
                     # Notify consumers of the start of a new output message + first content part
                     yield ResponseOutputItemAddedEvent(
                         item=assistant_item,
@@ -185,10 +278,20 @@ class ChatCmplStreamHandler:
                             text="",
                             type="output_text",
                             annotations=[],
+                            logprobs=[],
                         ),
                         type="response.content_part.added",
                         sequence_number=sequence_number.get_and_increment(),
                     )
+                delta_logprobs = (
+                    ChatCmplHelpers.convert_logprobs_for_text_delta(
+                        choice_logprobs.content if choice_logprobs else None
+                    )
+                    or []
+                )
+                output_logprobs = ChatCmplHelpers.convert_logprobs_for_output_text(
+                    choice_logprobs.content if choice_logprobs else None
+                )
                 # Emit the delta for this segment of content
                 yield ResponseTextDeltaEvent(
                     content_index=state.text_content_index_and_output[0],
@@ -198,10 +301,15 @@ class ChatCmplStreamHandler:
                     is not None,  # fixed 0 -> 0 or 1
                     type="response.output_text.delta",
                     sequence_number=sequence_number.get_and_increment(),
-                    logprobs=[],
+                    logprobs=delta_logprobs,
                 )
                 # Accumulate the text into the response part
                 state.text_content_index_and_output[1].text += delta.content
+                if output_logprobs:
+                    existing_logprobs = state.text_content_index_and_output[1].logprobs or []
+                    state.text_content_index_and_output[1].logprobs = (
+                        existing_logprobs + output_logprobs
+                    )
 
             # Handle refusals (model declines to answer)
             # This is always set by the OpenAI API, but not by others e.g. LiteLLM
@@ -225,6 +333,8 @@ class ChatCmplStreamHandler:
                         type="message",
                         status="in_progress",
                     )
+                    if state.provider_data:
+                        assistant_item.provider_data = state.provider_data.copy()  # type: ignore[attr-defined]
                     # Notify downstream that assistant message + first content part are starting
                     yield ResponseOutputItemAddedEvent(
                         item=assistant_item,
@@ -236,12 +346,10 @@ class ChatCmplStreamHandler:
                     yield ResponseContentPartAddedEvent(
                         content_index=state.refusal_content_index_and_output[0],
                         item_id=FAKE_RESPONSES_ID,
-                        output_index=state.reasoning_content_index_and_output
-                        is not None,  # fixed 0 -> 0 or 1
-                        part=ResponseOutputText(
-                            text="",
-                            type="output_text",
-                            annotations=[],
+                        output_index=(1 if state.reasoning_content_index_and_output else 0),
+                        part=ResponseOutputRefusal(
+                            refusal="",
+                            type="refusal",
                         ),
                         type="response.content_part.added",
                         sequence_number=sequence_number.get_and_increment(),
@@ -284,7 +392,60 @@ class ChatCmplStreamHandler:
                         state.function_calls[tc_delta.index].name = tc_function.name
 
                     if tc_delta.id:
-                        state.function_calls[tc_delta.index].call_id = tc_delta.id
+                        # Clean up litellm's addition of __thought__ suffix to tool_call.id for
+                        # Gemini models. See: https://github.com/BerriAI/litellm/pull/16895
+                        # This suffix is redundant since we can get thought_signature from
+                        # provider_specific_fields, and this hack causes validation errors when
+                        # cross-model passing to other models.
+                        tool_call_id = tc_delta.id
+                        if model and "gemini" in model.lower() and "__thought__" in tool_call_id:
+                            tool_call_id = tool_call_id.split("__thought__")[0]
+
+                        state.function_calls[tc_delta.index].call_id = tool_call_id
+
+                    # Initialize provider_data for this function call from state.provider_data
+                    if not hasattr(state.function_calls[tc_delta.index], "provider_data"):
+                        if state.provider_data:
+                            state.function_calls[
+                                tc_delta.index
+                            ].provider_data = state.provider_data.copy()  # type: ignore[attr-defined]
+
+                    # Capture provider_specific_fields data from LiteLLM
+                    if (
+                        hasattr(tc_delta, "provider_specific_fields")
+                        and tc_delta.provider_specific_fields
+                    ):
+                        # Handle Gemini thought_signatures
+                        if model and "gemini" in model.lower():
+                            provider_specific_fields = tc_delta.provider_specific_fields
+                            if isinstance(provider_specific_fields, dict):
+                                thought_sig = provider_specific_fields.get("thought_signature")
+                                if thought_sig:
+                                    # Start with state.provider_data, then add thought_signature
+                                    func_provider_data = (
+                                        state.provider_data.copy() if state.provider_data else {}
+                                    )
+                                    func_provider_data["thought_signature"] = thought_sig
+                                    state.function_calls[
+                                        tc_delta.index
+                                    ].provider_data = func_provider_data  # type: ignore[attr-defined]
+
+                    # Capture extra_content data from Google's chatcmpl endpoint
+                    if hasattr(tc_delta, "extra_content") and tc_delta.extra_content:
+                        extra_content = tc_delta.extra_content
+                        if isinstance(extra_content, dict):
+                            google_fields = extra_content.get("google")
+                            if google_fields and isinstance(google_fields, dict):
+                                thought_sig = google_fields.get("thought_signature")
+                                if thought_sig:
+                                    # Start with state.provider_data, then add thought_signature
+                                    func_provider_data = (
+                                        state.provider_data.copy() if state.provider_data else {}
+                                    )
+                                    func_provider_data["thought_signature"] = thought_sig
+                                    state.function_calls[
+                                        tc_delta.index
+                                    ].provider_data = func_provider_data  # type: ignore[attr-defined]
 
                     function_call = state.function_calls[tc_delta.index]
 
@@ -315,14 +476,28 @@ class ChatCmplStreamHandler:
                         )
 
                         # Send initial function call added event
+                        func_call_item = ResponseFunctionToolCall(
+                            id=FAKE_RESPONSES_ID,
+                            call_id=function_call.call_id,
+                            arguments="",  # Start with empty arguments
+                            name=function_call.name,
+                            type="function_call",
+                        )
+                        # Merge provider_data from state and function_call (e.g. thought_signature)
+                        if state.provider_data or (
+                            hasattr(function_call, "provider_data") and function_call.provider_data
+                        ):
+                            merged_provider_data = (
+                                state.provider_data.copy() if state.provider_data else {}
+                            )
+                            if (
+                                hasattr(function_call, "provider_data")
+                                and function_call.provider_data
+                            ):
+                                merged_provider_data.update(function_call.provider_data)
+                            func_call_item.provider_data = merged_provider_data  # type: ignore[attr-defined]
                         yield ResponseOutputItemAddedEvent(
-                            item=ResponseFunctionToolCall(
-                                id=FAKE_RESPONSES_ID,
-                                call_id=function_call.call_id,
-                                arguments="",  # Start with empty arguments
-                                name=function_call.name,
-                                type="function_call",
-                            ),
+                            item=func_call_item,
                             output_index=function_call_starting_index,
                             type="response.output_item.added",
                             sequence_number=sequence_number.get_and_increment(),
@@ -344,17 +519,30 @@ class ChatCmplStreamHandler:
                         )
 
         if state.reasoning_content_index_and_output:
-            yield ResponseReasoningSummaryPartDoneEvent(
-                item_id=FAKE_RESPONSES_ID,
-                output_index=0,
-                summary_index=0,
-                part=DoneEventPart(
-                    text=state.reasoning_content_index_and_output[1].summary[0].text,
-                    type="summary_text",
-                ),
-                type="response.reasoning_summary_part.done",
-                sequence_number=sequence_number.get_and_increment(),
-            )
+            if (
+                state.reasoning_content_index_and_output[1].summary
+                and len(state.reasoning_content_index_and_output[1].summary) > 0
+            ):
+                yield ResponseReasoningSummaryPartDoneEvent(
+                    item_id=FAKE_RESPONSES_ID,
+                    output_index=0,
+                    summary_index=0,
+                    part=DoneEventPart(
+                        text=state.reasoning_content_index_and_output[1].summary[0].text,
+                        type="summary_text",
+                    ),
+                    type="response.reasoning_summary_part.done",
+                    sequence_number=sequence_number.get_and_increment(),
+                )
+            elif state.reasoning_content_index_and_output[1].content is not None:
+                yield ResponseReasoningTextDoneEvent(
+                    item_id=FAKE_RESPONSES_ID,
+                    output_index=0,
+                    content_index=0,
+                    text=state.reasoning_content_index_and_output[1].content[0].text,
+                    type="response.reasoning_text.done",
+                    sequence_number=sequence_number.get_and_increment(),
+                )
             yield ResponseOutputItemDoneEvent(
                 item=state.reasoning_content_index_and_output[1],
                 output_index=0,
@@ -397,14 +585,27 @@ class ChatCmplStreamHandler:
             if state.function_call_streaming.get(index, False):
                 # Function call was streamed, just send the completion event
                 output_index = state.function_call_output_idx[index]
+
+                # Build function call kwargs, include provider_data if present
+                func_call_kwargs: dict[str, Any] = {
+                    "id": FAKE_RESPONSES_ID,
+                    "call_id": function_call.call_id,
+                    "arguments": function_call.arguments,
+                    "name": function_call.name,
+                    "type": "function_call",
+                }
+
+                # Merge provider_data from state and function_call (e.g. thought_signature)
+                if state.provider_data or (
+                    hasattr(function_call, "provider_data") and function_call.provider_data
+                ):
+                    merged_provider_data = state.provider_data.copy() if state.provider_data else {}
+                    if hasattr(function_call, "provider_data") and function_call.provider_data:
+                        merged_provider_data.update(function_call.provider_data)
+                    func_call_kwargs["provider_data"] = merged_provider_data
+
                 yield ResponseOutputItemDoneEvent(
-                    item=ResponseFunctionToolCall(
-                        id=FAKE_RESPONSES_ID,
-                        call_id=function_call.call_id,
-                        arguments=function_call.arguments,
-                        name=function_call.name,
-                        type="function_call",
-                    ),
+                    item=ResponseFunctionToolCall(**func_call_kwargs),
                     output_index=output_index,
                     type="response.output_item.done",
                     sequence_number=sequence_number.get_and_increment(),
@@ -425,15 +626,27 @@ class ChatCmplStreamHandler:
                     1 for streaming in state.function_call_streaming.values() if streaming
                 )
 
+                # Build function call kwargs, include provider_data if present
+                fallback_func_call_kwargs: dict[str, Any] = {
+                    "id": FAKE_RESPONSES_ID,
+                    "call_id": function_call.call_id,
+                    "arguments": function_call.arguments,
+                    "name": function_call.name,
+                    "type": "function_call",
+                }
+
+                # Merge provider_data from state and function_call (e.g. thought_signature)
+                if state.provider_data or (
+                    hasattr(function_call, "provider_data") and function_call.provider_data
+                ):
+                    merged_provider_data = state.provider_data.copy() if state.provider_data else {}
+                    if hasattr(function_call, "provider_data") and function_call.provider_data:
+                        merged_provider_data.update(function_call.provider_data)
+                    fallback_func_call_kwargs["provider_data"] = merged_provider_data
+
                 # Send all events at once (backward compatibility)
                 yield ResponseOutputItemAddedEvent(
-                    item=ResponseFunctionToolCall(
-                        id=FAKE_RESPONSES_ID,
-                        call_id=function_call.call_id,
-                        arguments=function_call.arguments,
-                        name=function_call.name,
-                        type="function_call",
-                    ),
+                    item=ResponseFunctionToolCall(**fallback_func_call_kwargs),
                     output_index=fallback_starting_index,
                     type="response.output_item.added",
                     sequence_number=sequence_number.get_and_increment(),
@@ -446,13 +659,7 @@ class ChatCmplStreamHandler:
                     sequence_number=sequence_number.get_and_increment(),
                 )
                 yield ResponseOutputItemDoneEvent(
-                    item=ResponseFunctionToolCall(
-                        id=FAKE_RESPONSES_ID,
-                        call_id=function_call.call_id,
-                        arguments=function_call.arguments,
-                        name=function_call.name,
-                        type="function_call",
-                    ),
+                    item=ResponseFunctionToolCall(**fallback_func_call_kwargs),
                     output_index=fallback_starting_index,
                     type="response.output_item.done",
                     sequence_number=sequence_number.get_and_increment(),
@@ -463,7 +670,19 @@ class ChatCmplStreamHandler:
 
         # include Reasoning item if it exists
         if state.reasoning_content_index_and_output:
-            outputs.append(state.reasoning_content_index_and_output[1])
+            reasoning_item = state.reasoning_content_index_and_output[1]
+            # Store thinking text in content and signature in encrypted_content
+            if state.thinking_text:
+                # Add thinking text as a Content object
+                if not reasoning_item.content:
+                    reasoning_item.content = []
+                reasoning_item.content.append(
+                    Content(text=state.thinking_text, type="reasoning_text")
+                )
+            # Store signature in encrypted_content
+            if state.thinking_signature:
+                reasoning_item.encrypted_content = state.thinking_signature
+            outputs.append(reasoning_item)
 
         # include text or refusal content if they exist
         if state.text_content_index_and_output or state.refusal_content_index_and_output:
@@ -474,6 +693,8 @@ class ChatCmplStreamHandler:
                 type="message",
                 status="completed",
             )
+            if state.provider_data:
+                assistant_msg.provider_data = state.provider_data.copy()  # type: ignore[attr-defined]
             if state.text_content_index_and_output:
                 assistant_msg.content.append(state.text_content_index_and_output[1])
             if state.refusal_content_index_and_output:
@@ -494,6 +715,7 @@ class ChatCmplStreamHandler:
 
         final_response = response.model_copy()
         final_response.output = outputs
+
         final_response.usage = (
             ResponseUsage(
                 input_tokens=usage.prompt_tokens or 0,

agents/models/default_models.py

@@ -0,0 +1,58 @@
+import copy
+import os
+from typing import Optional
+
+from openai.types.shared.reasoning import Reasoning
+
+from agents.model_settings import ModelSettings
+
+OPENAI_DEFAULT_MODEL_ENV_VARIABLE_NAME = "OPENAI_DEFAULT_MODEL"
+
+# discourage directly accessing this constant
+# use the get_default_model and get_default_model_settings() functions instead
+_GPT_5_DEFAULT_MODEL_SETTINGS: ModelSettings = ModelSettings(
+    # We chose "low" instead of "minimal" because some of the built-in tools
+    # (e.g., file search, image generation, etc.) do not support "minimal"
+    # If you want to use "minimal" reasoning effort, you can pass your own model settings
+    reasoning=Reasoning(effort="low"),
+    verbosity="low",
+)
+
+
+def gpt_5_reasoning_settings_required(model_name: str) -> bool:
+    """
+    Returns True if the model name is a GPT-5 model and reasoning settings are required.
+    """
+    if model_name.startswith("gpt-5-chat"):
+        # gpt-5-chat-latest does not require reasoning settings
+        return False
+    # matches any of gpt-5 models
+    return model_name.startswith("gpt-5")
+
+
+def is_gpt_5_default() -> bool:
+    """
+    Returns True if the default model is a GPT-5 model.
+    This is used to determine if the default model settings are compatible with GPT-5 models.
+    If the default model is not a GPT-5 model, the model settings are compatible with other models.
+    """
+    return gpt_5_reasoning_settings_required(get_default_model())
+
+
+def get_default_model() -> str:
+    """
+    Returns the default model name.
+    """
+    return os.getenv(OPENAI_DEFAULT_MODEL_ENV_VARIABLE_NAME, "gpt-4.1").lower()
+
+
+def get_default_model_settings(model: Optional[str] = None) -> ModelSettings:
+    """
+    Returns the default model settings.
+    If the default model is a GPT-5 model, returns the GPT-5 default model settings.
+    Otherwise, returns the legacy default model settings.
+    """
+    _model = model if model is not None else get_default_model()
+    if gpt_5_reasoning_settings_required(_model):
+        return copy.deepcopy(_GPT_5_DEFAULT_MODEL_SETTINGS)
+    return ModelSettings()

agents/models/interface.py

@@ -48,6 +48,7 @@ class Model(abc.ABC):
         tracing: ModelTracing,
         *,
         previous_response_id: str | None,
+        conversation_id: str | None,
         prompt: ResponsePromptParam | None,
     ) -> ModelResponse:
         """Get a response from the model.
@@ -62,6 +63,7 @@ class Model(abc.ABC):
             tracing: Tracing configuration.
             previous_response_id: the ID of the previous response. Generally not used by the model,
                 except for the OpenAI Responses API.
+            conversation_id: The ID of the stored conversation, if any.
             prompt: The prompt config to use for the model.
 
         Returns:
@@ -81,6 +83,7 @@ class Model(abc.ABC):
         tracing: ModelTracing,
         *,
         previous_response_id: str | None,
+        conversation_id: str | None,
         prompt: ResponsePromptParam | None,
     ) -> AsyncIterator[TResponseStreamEvent]:
         """Stream a response from the model.
@@ -95,6 +98,7 @@ class Model(abc.ABC):
             tracing: Tracing configuration.
             previous_response_id: the ID of the previous response. Generally not used by the model,
                 except for the OpenAI Responses API.
+            conversation_id: The ID of the stored conversation, if any.
             prompt: The prompt config to use for the model.
 
         Returns: