aimlapi-sdk-python 2.8.1b0__py3-none-any.whl

openai/types/realtime/__init__.py

@@ -0,0 +1,237 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .realtime_error import RealtimeError as RealtimeError
+from .call_refer_params import CallReferParams as CallReferParams
+from .conversation_item import ConversationItem as ConversationItem
+from .realtime_response import RealtimeResponse as RealtimeResponse
+from .call_accept_params import CallAcceptParams as CallAcceptParams
+from .call_create_params import CallCreateParams as CallCreateParams
+from .call_reject_params import CallRejectParams as CallRejectParams
+from .audio_transcription import AudioTranscription as AudioTranscription
+from .log_prob_properties import LogProbProperties as LogProbProperties
+from .realtime_truncation import RealtimeTruncation as RealtimeTruncation
+from .response_done_event import ResponseDoneEvent as ResponseDoneEvent
+from .noise_reduction_type import NoiseReductionType as NoiseReductionType
+from .realtime_error_event import RealtimeErrorEvent as RealtimeErrorEvent
+from .session_update_event import SessionUpdateEvent as SessionUpdateEvent
+from .mcp_list_tools_failed import McpListToolsFailed as McpListToolsFailed
+from .realtime_audio_config import RealtimeAudioConfig as RealtimeAudioConfig
+from .realtime_client_event import RealtimeClientEvent as RealtimeClientEvent
+from .realtime_server_event import RealtimeServerEvent as RealtimeServerEvent
+from .realtime_tools_config import RealtimeToolsConfig as RealtimeToolsConfig
+from .response_cancel_event import ResponseCancelEvent as ResponseCancelEvent
+from .response_create_event import ResponseCreateEvent as ResponseCreateEvent
+from .session_created_event import SessionCreatedEvent as SessionCreatedEvent
+from .session_updated_event import SessionUpdatedEvent as SessionUpdatedEvent
+from .conversation_item_done import ConversationItemDone as ConversationItemDone
+from .realtime_audio_formats import RealtimeAudioFormats as RealtimeAudioFormats
+from .realtime_function_tool import RealtimeFunctionTool as RealtimeFunctionTool
+from .realtime_mcp_tool_call import RealtimeMcpToolCall as RealtimeMcpToolCall
+from .realtime_mcphttp_error import RealtimeMcphttpError as RealtimeMcphttpError
+from .response_created_event import ResponseCreatedEvent as ResponseCreatedEvent
+from .conversation_item_added import ConversationItemAdded as ConversationItemAdded
+from .conversation_item_param import ConversationItemParam as ConversationItemParam
+from .realtime_connect_params import RealtimeConnectParams as RealtimeConnectParams
+from .realtime_mcp_list_tools import RealtimeMcpListTools as RealtimeMcpListTools
+from .realtime_response_usage import RealtimeResponseUsage as RealtimeResponseUsage
+from .realtime_tracing_config import RealtimeTracingConfig as RealtimeTracingConfig
+from .mcp_list_tools_completed import McpListToolsCompleted as McpListToolsCompleted
+from .realtime_response_status import RealtimeResponseStatus as RealtimeResponseStatus
+from .response_mcp_call_failed import ResponseMcpCallFailed as ResponseMcpCallFailed
+from .response_text_done_event import ResponseTextDoneEvent as ResponseTextDoneEvent
+from .audio_transcription_param import AudioTranscriptionParam as AudioTranscriptionParam
+from .rate_limits_updated_event import RateLimitsUpdatedEvent as RateLimitsUpdatedEvent
+from .realtime_truncation_param import RealtimeTruncationParam as RealtimeTruncationParam
+from .response_audio_done_event import ResponseAudioDoneEvent as ResponseAudioDoneEvent
+from .response_text_delta_event import ResponseTextDeltaEvent as ResponseTextDeltaEvent
+from .conversation_created_event import ConversationCreatedEvent as ConversationCreatedEvent
+from .mcp_list_tools_in_progress import McpListToolsInProgress as McpListToolsInProgress
+from .response_audio_delta_event import ResponseAudioDeltaEvent as ResponseAudioDeltaEvent
+from .session_update_event_param import SessionUpdateEventParam as SessionUpdateEventParam
+from .client_secret_create_params import ClientSecretCreateParams as ClientSecretCreateParams
+from .realtime_audio_config_input import RealtimeAudioConfigInput as RealtimeAudioConfigInput
+from .realtime_audio_config_param import RealtimeAudioConfigParam as RealtimeAudioConfigParam
+from .realtime_client_event_param import RealtimeClientEventParam as RealtimeClientEventParam
+from .realtime_mcp_protocol_error import RealtimeMcpProtocolError as RealtimeMcpProtocolError
+from .realtime_tool_choice_config import RealtimeToolChoiceConfig as RealtimeToolChoiceConfig
+from .realtime_tools_config_param import RealtimeToolsConfigParam as RealtimeToolsConfigParam
+from .realtime_tools_config_union import RealtimeToolsConfigUnion as RealtimeToolsConfigUnion
+from .response_cancel_event_param import ResponseCancelEventParam as ResponseCancelEventParam
+from .response_create_event_param import ResponseCreateEventParam as ResponseCreateEventParam
+from .response_mcp_call_completed import ResponseMcpCallCompleted as ResponseMcpCallCompleted
+from .realtime_audio_config_output import RealtimeAudioConfigOutput as RealtimeAudioConfigOutput
+from .realtime_audio_formats_param import RealtimeAudioFormatsParam as RealtimeAudioFormatsParam
+from .realtime_function_tool_param import RealtimeFunctionToolParam as RealtimeFunctionToolParam
+from .realtime_mcp_tool_call_param import RealtimeMcpToolCallParam as RealtimeMcpToolCallParam
+from .realtime_mcphttp_error_param import RealtimeMcphttpErrorParam as RealtimeMcphttpErrorParam
+from .client_secret_create_response import ClientSecretCreateResponse as ClientSecretCreateResponse
+from .realtime_mcp_approval_request import RealtimeMcpApprovalRequest as RealtimeMcpApprovalRequest
+from .realtime_mcp_list_tools_param import RealtimeMcpListToolsParam as RealtimeMcpListToolsParam
+from .realtime_tracing_config_param import RealtimeTracingConfigParam as RealtimeTracingConfigParam
+from .response_mcp_call_in_progress import ResponseMcpCallInProgress as ResponseMcpCallInProgress
+from .conversation_item_create_event import ConversationItemCreateEvent as ConversationItemCreateEvent
+from .conversation_item_delete_event import ConversationItemDeleteEvent as ConversationItemDeleteEvent
+from .input_audio_buffer_clear_event import InputAudioBufferClearEvent as InputAudioBufferClearEvent
+from .realtime_mcp_approval_response import RealtimeMcpApprovalResponse as RealtimeMcpApprovalResponse
+from .realtime_session_client_secret import RealtimeSessionClientSecret as RealtimeSessionClientSecret
+from .conversation_item_created_event import ConversationItemCreatedEvent as ConversationItemCreatedEvent
+from .conversation_item_deleted_event import ConversationItemDeletedEvent as ConversationItemDeletedEvent
+from .input_audio_buffer_append_event import InputAudioBufferAppendEvent as InputAudioBufferAppendEvent
+from .input_audio_buffer_commit_event import InputAudioBufferCommitEvent as InputAudioBufferCommitEvent
+from .output_audio_buffer_clear_event import OutputAudioBufferClearEvent as OutputAudioBufferClearEvent
+from .realtime_response_create_params import RealtimeResponseCreateParams as RealtimeResponseCreateParams
+from .realtime_session_create_request import RealtimeSessionCreateRequest as RealtimeSessionCreateRequest
+from .response_output_item_done_event import ResponseOutputItemDoneEvent as ResponseOutputItemDoneEvent
+from .conversation_item_retrieve_event import ConversationItemRetrieveEvent as ConversationItemRetrieveEvent
+from .conversation_item_truncate_event import ConversationItemTruncateEvent as ConversationItemTruncateEvent
+from .input_audio_buffer_cleared_event import InputAudioBufferClearedEvent as InputAudioBufferClearedEvent
+from .realtime_session_create_response import RealtimeSessionCreateResponse as RealtimeSessionCreateResponse
+from .response_content_part_done_event import ResponseContentPartDoneEvent as ResponseContentPartDoneEvent
+from .response_mcp_call_arguments_done import ResponseMcpCallArgumentsDone as ResponseMcpCallArgumentsDone
+from .response_output_item_added_event import ResponseOutputItemAddedEvent as ResponseOutputItemAddedEvent
+from .conversation_item_truncated_event import ConversationItemTruncatedEvent as ConversationItemTruncatedEvent
+from .realtime_audio_config_input_param import RealtimeAudioConfigInputParam as RealtimeAudioConfigInputParam
+from .realtime_mcp_protocol_error_param import RealtimeMcpProtocolErrorParam as RealtimeMcpProtocolErrorParam
+from .realtime_mcp_tool_execution_error import RealtimeMcpToolExecutionError as RealtimeMcpToolExecutionError
+from .realtime_response_create_mcp_tool import RealtimeResponseCreateMcpTool as RealtimeResponseCreateMcpTool
+from .realtime_tool_choice_config_param import RealtimeToolChoiceConfigParam as RealtimeToolChoiceConfigParam
+from .realtime_tools_config_union_param import RealtimeToolsConfigUnionParam as RealtimeToolsConfigUnionParam
+from .response_content_part_added_event import ResponseContentPartAddedEvent as ResponseContentPartAddedEvent
+from .response_mcp_call_arguments_delta import ResponseMcpCallArgumentsDelta as ResponseMcpCallArgumentsDelta
+from .input_audio_buffer_committed_event import InputAudioBufferCommittedEvent as InputAudioBufferCommittedEvent
+from .realtime_audio_config_output_param import RealtimeAudioConfigOutputParam as RealtimeAudioConfigOutputParam
+from .realtime_audio_input_turn_detection import RealtimeAudioInputTurnDetection as RealtimeAudioInputTurnDetection
+from .realtime_mcp_approval_request_param import RealtimeMcpApprovalRequestParam as RealtimeMcpApprovalRequestParam
+from .realtime_truncation_retention_ratio import RealtimeTruncationRetentionRatio as RealtimeTruncationRetentionRatio
+from .conversation_item_create_event_param import ConversationItemCreateEventParam as ConversationItemCreateEventParam
+from .conversation_item_delete_event_param import ConversationItemDeleteEventParam as ConversationItemDeleteEventParam
+from .input_audio_buffer_clear_event_param import InputAudioBufferClearEventParam as InputAudioBufferClearEventParam
+from .input_audio_buffer_timeout_triggered import InputAudioBufferTimeoutTriggered as InputAudioBufferTimeoutTriggered
+from .realtime_mcp_approval_response_param import RealtimeMcpApprovalResponseParam as RealtimeMcpApprovalResponseParam
+from .realtime_transcription_session_audio import RealtimeTranscriptionSessionAudio as RealtimeTranscriptionSessionAudio
+from .response_audio_transcript_done_event import ResponseAudioTranscriptDoneEvent as ResponseAudioTranscriptDoneEvent
+from .input_audio_buffer_append_event_param import InputAudioBufferAppendEventParam as InputAudioBufferAppendEventParam
+from .input_audio_buffer_commit_event_param import InputAudioBufferCommitEventParam as InputAudioBufferCommitEventParam
+from .output_audio_buffer_clear_event_param import OutputAudioBufferClearEventParam as OutputAudioBufferClearEventParam
+from .realtime_response_create_audio_output import (
+    RealtimeResponseCreateAudioOutput as RealtimeResponseCreateAudioOutput,
+)
+from .realtime_response_create_params_param import (
+    RealtimeResponseCreateParamsParam as RealtimeResponseCreateParamsParam,
+)
+from .realtime_session_create_request_param import (
+    RealtimeSessionCreateRequestParam as RealtimeSessionCreateRequestParam,
+)
+from .response_audio_transcript_delta_event import (
+    ResponseAudioTranscriptDeltaEvent as ResponseAudioTranscriptDeltaEvent,
+)
+from .conversation_item_retrieve_event_param import (
+    ConversationItemRetrieveEventParam as ConversationItemRetrieveEventParam,
+)
+from .conversation_item_truncate_event_param import (
+    ConversationItemTruncateEventParam as ConversationItemTruncateEventParam,
+)
+from .input_audio_buffer_speech_started_event import (
+    InputAudioBufferSpeechStartedEvent as InputAudioBufferSpeechStartedEvent,
+)
+from .input_audio_buffer_speech_stopped_event import (
+    InputAudioBufferSpeechStoppedEvent as InputAudioBufferSpeechStoppedEvent,
+)
+from .realtime_conversation_item_user_message import (
+    RealtimeConversationItemUserMessage as RealtimeConversationItemUserMessage,
+)
+from .realtime_mcp_tool_execution_error_param import (
+    RealtimeMcpToolExecutionErrorParam as RealtimeMcpToolExecutionErrorParam,
+)
+from .realtime_response_create_mcp_tool_param import (
+    RealtimeResponseCreateMcpToolParam as RealtimeResponseCreateMcpToolParam,
+)
+from .realtime_conversation_item_function_call import (
+    RealtimeConversationItemFunctionCall as RealtimeConversationItemFunctionCall,
+)
+from .realtime_audio_input_turn_detection_param import (
+    RealtimeAudioInputTurnDetectionParam as RealtimeAudioInputTurnDetectionParam,
+)
+from .realtime_conversation_item_system_message import (
+    RealtimeConversationItemSystemMessage as RealtimeConversationItemSystemMessage,
+)
+from .realtime_truncation_retention_ratio_param import (
+    RealtimeTruncationRetentionRatioParam as RealtimeTruncationRetentionRatioParam,
+)
+from .realtime_transcription_session_audio_input import (
+    RealtimeTranscriptionSessionAudioInput as RealtimeTranscriptionSessionAudioInput,
+)
+from .realtime_transcription_session_audio_param import (
+    RealtimeTranscriptionSessionAudioParam as RealtimeTranscriptionSessionAudioParam,
+)
+from .realtime_response_create_audio_output_param import (
+    RealtimeResponseCreateAudioOutputParam as RealtimeResponseCreateAudioOutputParam,
+)
+from .realtime_response_usage_input_token_details import (
+    RealtimeResponseUsageInputTokenDetails as RealtimeResponseUsageInputTokenDetails,
+)
+from .response_function_call_arguments_done_event import (
+    ResponseFunctionCallArgumentsDoneEvent as ResponseFunctionCallArgumentsDoneEvent,
+)
+from .realtime_conversation_item_assistant_message import (
+    RealtimeConversationItemAssistantMessage as RealtimeConversationItemAssistantMessage,
+)
+from .realtime_response_usage_output_token_details import (
+    RealtimeResponseUsageOutputTokenDetails as RealtimeResponseUsageOutputTokenDetails,
+)
+from .response_function_call_arguments_delta_event import (
+    ResponseFunctionCallArgumentsDeltaEvent as ResponseFunctionCallArgumentsDeltaEvent,
+)
+from .realtime_conversation_item_user_message_param import (
+    RealtimeConversationItemUserMessageParam as RealtimeConversationItemUserMessageParam,
+)
+from .realtime_transcription_session_create_request import (
+    RealtimeTranscriptionSessionCreateRequest as RealtimeTranscriptionSessionCreateRequest,
+)
+from .realtime_transcription_session_turn_detection import (
+    RealtimeTranscriptionSessionTurnDetection as RealtimeTranscriptionSessionTurnDetection,
+)
+from .realtime_conversation_item_function_call_param import (
+    RealtimeConversationItemFunctionCallParam as RealtimeConversationItemFunctionCallParam,
+)
+from .realtime_transcription_session_create_response import (
+    RealtimeTranscriptionSessionCreateResponse as RealtimeTranscriptionSessionCreateResponse,
+)
+from .realtime_conversation_item_function_call_output import (
+    RealtimeConversationItemFunctionCallOutput as RealtimeConversationItemFunctionCallOutput,
+)
+from .realtime_conversation_item_system_message_param import (
+    RealtimeConversationItemSystemMessageParam as RealtimeConversationItemSystemMessageParam,
+)
+from .realtime_transcription_session_audio_input_param import (
+    RealtimeTranscriptionSessionAudioInputParam as RealtimeTranscriptionSessionAudioInputParam,
+)
+from .realtime_conversation_item_assistant_message_param import (
+    RealtimeConversationItemAssistantMessageParam as RealtimeConversationItemAssistantMessageParam,
+)
+from .conversation_item_input_audio_transcription_segment import (
+    ConversationItemInputAudioTranscriptionSegment as ConversationItemInputAudioTranscriptionSegment,
+)
+from .realtime_transcription_session_create_request_param import (
+    RealtimeTranscriptionSessionCreateRequestParam as RealtimeTranscriptionSessionCreateRequestParam,
+)
+from .realtime_conversation_item_function_call_output_param import (
+    RealtimeConversationItemFunctionCallOutputParam as RealtimeConversationItemFunctionCallOutputParam,
+)
+from .conversation_item_input_audio_transcription_delta_event import (
+    ConversationItemInputAudioTranscriptionDeltaEvent as ConversationItemInputAudioTranscriptionDeltaEvent,
+)
+from .conversation_item_input_audio_transcription_failed_event import (
+    ConversationItemInputAudioTranscriptionFailedEvent as ConversationItemInputAudioTranscriptionFailedEvent,
+)
+from .realtime_transcription_session_audio_input_turn_detection import (
+    RealtimeTranscriptionSessionAudioInputTurnDetection as RealtimeTranscriptionSessionAudioInputTurnDetection,
+)
+from .conversation_item_input_audio_transcription_completed_event import (
+    ConversationItemInputAudioTranscriptionCompletedEvent as ConversationItemInputAudioTranscriptionCompletedEvent,
+)
+from .realtime_transcription_session_audio_input_turn_detection_param import (
+    RealtimeTranscriptionSessionAudioInputTurnDetectionParam as RealtimeTranscriptionSessionAudioInputTurnDetectionParam,
+)

openai/types/realtime/audio_transcription.py

@@ -0,0 +1,37 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["AudioTranscription"]
+
+
+class AudioTranscription(BaseModel):
+    language: Optional[str] = None
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Optional[
+        Literal["whisper-1", "gpt-4o-mini-transcribe", "gpt-4o-transcribe", "gpt-4o-transcribe-diarize"]
+    ] = None
+    """The model to use for transcription.
+
+    Current options are `whisper-1`, `gpt-4o-mini-transcribe`, `gpt-4o-transcribe`,
+    and `gpt-4o-transcribe-diarize`. Use `gpt-4o-transcribe-diarize` when you need
+    diarization with speaker labels.
+    """
+
+    prompt: Optional[str] = None
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models (excluding `gpt-4o-transcribe-diarize`), the
+    prompt is a free text string, for example "expect words related to technology".
+    """

openai/types/realtime/audio_transcription_param.py

@@ -0,0 +1,34 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["AudioTranscriptionParam"]
+
+
+class AudioTranscriptionParam(TypedDict, total=False):
+    language: str
+    """The language of the input audio.
+
+    Supplying the input language in
+    [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
+    format will improve accuracy and latency.
+    """
+
+    model: Literal["whisper-1", "gpt-4o-mini-transcribe", "gpt-4o-transcribe", "gpt-4o-transcribe-diarize"]
+    """The model to use for transcription.
+
+    Current options are `whisper-1`, `gpt-4o-mini-transcribe`, `gpt-4o-transcribe`,
+    and `gpt-4o-transcribe-diarize`. Use `gpt-4o-transcribe-diarize` when you need
+    diarization with speaker labels.
+    """
+
+    prompt: str
+    """
+    An optional text to guide the model's style or continue a previous audio
+    segment. For `whisper-1`, the
+    [prompt is a list of keywords](https://platform.openai.com/docs/guides/speech-to-text#prompting).
+    For `gpt-4o-transcribe` models (excluding `gpt-4o-transcribe-diarize`), the
+    prompt is a free text string, for example "expect words related to technology".
+    """

openai/types/realtime/call_accept_params.py

@@ -0,0 +1,122 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from .realtime_truncation_param import RealtimeTruncationParam
+from .realtime_audio_config_param import RealtimeAudioConfigParam
+from .realtime_tools_config_param import RealtimeToolsConfigParam
+from .realtime_tracing_config_param import RealtimeTracingConfigParam
+from ..responses.response_prompt_param import ResponsePromptParam
+from .realtime_tool_choice_config_param import RealtimeToolChoiceConfigParam
+
+__all__ = ["CallAcceptParams"]
+
+
+class CallAcceptParams(TypedDict, total=False):
+    type: Required[Literal["realtime"]]
+    """The type of session to create. Always `realtime` for the Realtime API."""
+
+    audio: RealtimeAudioConfigParam
+    """Configuration for input and output audio."""
+
+    include: List[Literal["item.input_audio_transcription.logprobs"]]
+    """Additional fields to include in server outputs.
+
+    `item.input_audio_transcription.logprobs`: Include logprobs for input audio
+    transcription.
+    """
+
+    instructions: str
+    """The default system instructions (i.e.
+
+    system message) prepended to model calls. This field allows the client to guide
+    the model on desired responses. The model can be instructed on response content
+    and format, (e.g. "be extremely succinct", "act friendly", "here are examples of
+    good responses") and on audio behavior (e.g. "talk quickly", "inject emotion
+    into your voice", "laugh frequently"). The instructions are not guaranteed to be
+    followed by the model, but they provide guidance to the model on the desired
+    behavior.
+
+    Note that the server sets default instructions which will be used if this field
+    is not set and are visible in the `session.created` event at the start of the
+    session.
+    """
+
+    max_output_tokens: Union[int, Literal["inf"]]
+    """
+    Maximum number of output tokens for a single assistant response, inclusive of
+    tool calls. Provide an integer between 1 and 4096 to limit output tokens, or
+    `inf` for the maximum available tokens for a given model. Defaults to `inf`.
+    """
+
+    model: Union[
+        str,
+        Literal[
+            "gpt-realtime",
+            "gpt-realtime-2025-08-28",
+            "gpt-4o-realtime-preview",
+            "gpt-4o-realtime-preview-2024-10-01",
+            "gpt-4o-realtime-preview-2024-12-17",
+            "gpt-4o-realtime-preview-2025-06-03",
+            "gpt-4o-mini-realtime-preview",
+            "gpt-4o-mini-realtime-preview-2024-12-17",
+            "gpt-realtime-mini",
+            "gpt-realtime-mini-2025-10-06",
+            "gpt-audio-mini",
+            "gpt-audio-mini-2025-10-06",
+        ],
+    ]
+    """The Realtime model used for this session."""
+
+    output_modalities: List[Literal["text", "audio"]]
+    """The set of modalities the model can respond with.
+
+    It defaults to `["audio"]`, indicating that the model will respond with audio
+    plus a transcript. `["text"]` can be used to make the model respond with text
+    only. It is not possible to request both `text` and `audio` at the same time.
+    """
+
+    prompt: Optional[ResponsePromptParam]
+    """
+    Reference to a prompt template and its variables.
+    [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
+    """
+
+    tool_choice: RealtimeToolChoiceConfigParam
+    """How the model chooses tools.
+
+    Provide one of the string modes or force a specific function/MCP tool.
+    """
+
+    tools: RealtimeToolsConfigParam
+    """Tools available to the model."""
+
+    tracing: Optional[RealtimeTracingConfigParam]
+    """
+    Realtime API can write session traces to the
+    [Traces Dashboard](/logs?api=traces). Set to null to disable tracing. Once
+    tracing is enabled for a session, the configuration cannot be modified.
+
+    `auto` will create a trace for the session with default values for the workflow
+    name, group id, and metadata.
+    """
+
+    truncation: RealtimeTruncationParam
+    """
+    When the number of tokens in a conversation exceeds the model's input token
+    limit, the conversation be truncated, meaning messages (starting from the
+    oldest) will not be included in the model's context. A 32k context model with
+    4,096 max output tokens can only include 28,224 tokens in the context before
+    truncation occurs. Clients can configure truncation behavior to truncate with a
+    lower max token limit, which is an effective way to control token usage and
+    cost. Truncation will reduce the number of cached tokens on the next turn
+    (busting the cache), since messages are dropped from the beginning of the
+    context. However, clients can also configure truncation to retain messages up to
+    a fraction of the maximum context size, which will reduce the need for future
+    truncations and thus improve the cache rate. Truncation can be disabled
+    entirely, which means the server will never truncate but would instead return an
+    error if the conversation exceeds the model's input token limit.
+    """

openai/types/realtime/call_create_params.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+from .realtime_session_create_request_param import RealtimeSessionCreateRequestParam
+
+__all__ = ["CallCreateParams"]
+
+
+class CallCreateParams(TypedDict, total=False):
+    sdp: Required[str]
+    """WebRTC Session Description Protocol (SDP) offer generated by the caller."""
+
+    session: RealtimeSessionCreateRequestParam
+    """Realtime session object configuration."""

openai/types/realtime/call_refer_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["CallReferParams"]
+
+
+class CallReferParams(TypedDict, total=False):
+    target_uri: Required[str]
+    """URI that should appear in the SIP Refer-To header.
+
+    Supports values like `tel:+14155550123` or `sip:agent@example.com`.
+    """

openai/types/realtime/call_reject_params.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import TypedDict
+
+__all__ = ["CallRejectParams"]
+
+
+class CallRejectParams(TypedDict, total=False):
+    status_code: int
+    """SIP response code to send back to the caller.
+
+    Defaults to `603` (Decline) when omitted.
+    """

openai/types/realtime/client_secret_create_params.py

@@ -0,0 +1,46 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, TypeAlias, TypedDict
+
+from .realtime_session_create_request_param import RealtimeSessionCreateRequestParam
+from .realtime_transcription_session_create_request_param import RealtimeTranscriptionSessionCreateRequestParam
+
+__all__ = ["ClientSecretCreateParams", "ExpiresAfter", "Session"]
+
+
+class ClientSecretCreateParams(TypedDict, total=False):
+    expires_after: ExpiresAfter
+    """Configuration for the client secret expiration.
+
+    Expiration refers to the time after which a client secret will no longer be
+    valid for creating sessions. The session itself may continue after that time
+    once started. A secret can be used to create multiple sessions until it expires.
+    """
+
+    session: Session
+    """Session configuration to use for the client secret.
+
+    Choose either a realtime session or a transcription session.
+    """
+
+
+class ExpiresAfter(TypedDict, total=False):
+    anchor: Literal["created_at"]
+    """
+    The anchor point for the client secret expiration, meaning that `seconds` will
+    be added to the `created_at` time of the client secret to produce an expiration
+    timestamp. Only `created_at` is currently supported.
+    """
+
+    seconds: int
+    """The number of seconds from the anchor point to the expiration.
+
+    Select a value between `10` and `7200` (2 hours). This default to 600 seconds
+    (10 minutes) if not specified.
+    """
+
+
+Session: TypeAlias = Union[RealtimeSessionCreateRequestParam, RealtimeTranscriptionSessionCreateRequestParam]

openai/types/realtime/client_secret_create_response.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .realtime_session_create_response import RealtimeSessionCreateResponse
+from .realtime_transcription_session_create_response import RealtimeTranscriptionSessionCreateResponse
+
+__all__ = ["ClientSecretCreateResponse", "Session"]
+
+Session: TypeAlias = Annotated[
+    Union[RealtimeSessionCreateResponse, RealtimeTranscriptionSessionCreateResponse], PropertyInfo(discriminator="type")
+]
+
+
+class ClientSecretCreateResponse(BaseModel):
+    expires_at: int
+    """Expiration timestamp for the client secret, in seconds since epoch."""
+
+    session: Session
+    """The session configuration for either a realtime or transcription session."""
+
+    value: str
+    """The generated client secret value."""

openai/types/realtime/conversation_created_event.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["ConversationCreatedEvent", "Conversation"]
+
+
+class Conversation(BaseModel):
+    id: Optional[str] = None
+    """The unique ID of the conversation."""
+
+    object: Optional[Literal["realtime.conversation"]] = None
+    """The object type, must be `realtime.conversation`."""
+
+
+class ConversationCreatedEvent(BaseModel):
+    conversation: Conversation
+    """The conversation resource."""
+
+    event_id: str
+    """The unique ID of the server event."""
+
+    type: Literal["conversation.created"]
+    """The event type, must be `conversation.created`."""

openai/types/realtime/conversation_item.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .realtime_mcp_tool_call import RealtimeMcpToolCall
+from .realtime_mcp_list_tools import RealtimeMcpListTools
+from .realtime_mcp_approval_request import RealtimeMcpApprovalRequest
+from .realtime_mcp_approval_response import RealtimeMcpApprovalResponse
+from .realtime_conversation_item_user_message import RealtimeConversationItemUserMessage
+from .realtime_conversation_item_function_call import RealtimeConversationItemFunctionCall
+from .realtime_conversation_item_system_message import RealtimeConversationItemSystemMessage
+from .realtime_conversation_item_assistant_message import RealtimeConversationItemAssistantMessage
+from .realtime_conversation_item_function_call_output import RealtimeConversationItemFunctionCallOutput
+
+__all__ = ["ConversationItem"]
+
+ConversationItem: TypeAlias = Annotated[
+    Union[
+        RealtimeConversationItemSystemMessage,
+        RealtimeConversationItemUserMessage,
+        RealtimeConversationItemAssistantMessage,
+        RealtimeConversationItemFunctionCall,
+        RealtimeConversationItemFunctionCallOutput,
+        RealtimeMcpApprovalResponse,
+        RealtimeMcpListTools,
+        RealtimeMcpToolCall,
+        RealtimeMcpApprovalRequest,
+    ],
+    PropertyInfo(discriminator="type"),
+]

openai/types/realtime/conversation_item_added.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .conversation_item import ConversationItem
+
+__all__ = ["ConversationItemAdded"]
+
+
+class ConversationItemAdded(BaseModel):
+    event_id: str
+    """The unique ID of the server event."""
+
+    item: ConversationItem
+    """A single item within a Realtime conversation."""
+
+    type: Literal["conversation.item.added"]
+    """The event type, must be `conversation.item.added`."""
+
+    previous_item_id: Optional[str] = None
+    """The ID of the item that precedes this one, if any.
+
+    This is used to maintain ordering when items are inserted.
+    """