openai 0.88.0 → 0.89.0

data/rbi/openai/models/live/media_session_fork_config.rbi

@@ -0,0 +1,143 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class MediaSessionForkConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::MediaSessionForkConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+        # session. Trusted sideband connections are unaffected.
+        sig { returns(T.nilable(OpenAI::Live::ClientConfig)) }
+        attr_reader :client
+
+        sig { params(client: OpenAI::Live::ClientConfig::OrHash).void }
+        attr_writer :client
+
+        # Update the Responses backend for an existing Live session without changing
+        # delegation ownership.
+        sig { returns(T.nilable(OpenAI::Live::MediaSessionForkConfig::Delegation)) }
+        attr_reader :delegation
+
+        sig { params(delegation: OpenAI::Live::MediaSessionForkConfig::Delegation::OrHash).void }
+        attr_writer :delegation
+
+        # Whether to store the forked session. Omission inherits the stored session's
+        # setting.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :store
+
+        sig { params(store: T::Boolean).void }
+        attr_writer :store
+
+        # Optional overrides for a stored Live session. Omitted settings are inherited.
+        # The model, voice, frontend instructions, and prior conversation come from the
+        # stored session. WebRTC negotiates its audio format; audio.format is only
+        # supported on WebSocket forks.
+        sig do
+          params(
+
+            client: OpenAI::Live::ClientConfig::OrHash,
+
+            delegation: OpenAI::Live::MediaSessionForkConfig::Delegation::OrHash,
+
+            store: T::Boolean
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Startup-only capabilities for an untrusted frontend attached to a unified WebRTC
+          # session. Trusted sideband connections are unaffected.
+          client: nil,
+
+          # Update the Responses backend for an existing Live session without changing
+          # delegation ownership.
+          delegation: nil,
+
+          # Whether to store the forked session. Omission inherits the stored session's
+          # setting.
+
+          store: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              client: OpenAI::Live::ClientConfig,
+              delegation: OpenAI::Live::MediaSessionForkConfig::Delegation,
+              store: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Delegation < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::MediaSessionForkConfig::Delegation,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The delegation owner. Always `responses` for tasks handled by the Responses API.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Responses backend settings to update. Omitted settings keep their existing
+          # values.
+          sig { returns(T.nilable(OpenAI::Live::ResponsesDelegationUpdateConfig)) }
+          attr_reader :responses
+
+          sig { params(responses: OpenAI::Live::ResponsesDelegationUpdateConfig::OrHash).void }
+          attr_writer :responses
+
+          # Update the Responses backend for an existing Live session without changing
+          # delegation ownership.
+          sig do
+            params(
+
+              responses: OpenAI::Live::ResponsesDelegationUpdateConfig::OrHash,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Responses backend settings to update. Omitted settings keep their existing
+            # values.
+            responses: nil,
+
+            # The delegation owner. Always `responses` for tasks handled by the Responses API.
+
+            type: :responses
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol, responses: OpenAI::Live::ResponsesDelegationUpdateConfig}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/output_audio_delta_event.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class OutputAudioDeltaEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::OutputAudioDeltaEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Base64-encoded raw audio. Primary WebSocket events use the session's configured
+        # format; reflected sideband events use mono PCM16LE at 24 kHz.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The event type, always `session.output_audio.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Exclusive session-relative end in milliseconds. Required on reflected sideband
+        # events; omitted on the primary WebSocket. Dropped output frames leave gaps
+        # between reflected ranges.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :end_ms
+
+        sig { params(end_ms: Integer).void }
+        attr_writer :end_ms
+
+        # Inclusive session-relative start in milliseconds. Required on reflected sideband
+        # events; omitted on the primary WebSocket.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :start_ms
+
+        sig { params(start_ms: Integer).void }
+        attr_writer :start_ms
+
+        # An audio chunk generated by the Live model. Decode and play primary WebSocket
+        # chunks in delivery order using the configured session audio format. Sideband
+        # connections receive reflected output audio with timestamps.
+        sig do
+          params(
+
+            delta: String,
+
+            end_ms: Integer,
+
+            start_ms: Integer,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Base64-encoded raw audio. Primary WebSocket events use the session's configured
+          # format; reflected sideband events use mono PCM16LE at 24 kHz.
+          delta:,
+
+          # Exclusive session-relative end in milliseconds. Required on reflected sideband
+          # events; omitted on the primary WebSocket. Dropped output frames leave gaps
+          # between reflected ranges.
+          end_ms: nil,
+
+          # Inclusive session-relative start in milliseconds. Required on reflected sideband
+          # events; omitted on the primary WebSocket.
+          start_ms: nil,
+
+          # The event type, always `session.output_audio.delta`.
+
+          type: :"session.output_audio.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {delta: String, type: Symbol, end_ms: Integer, start_ms: Integer}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/output_transcript_delta_event.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class OutputTranscriptDeltaEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::OutputTranscriptDeltaEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The transcript text fragment for the audio in this time range. Append fragments
+        # in delivery order to build the transcript.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The end of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session. For appended context, this can equal start_ms.
+        sig { returns(Integer) }
+        attr_accessor :end_ms
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The start of this event on the Live session timeline, in milliseconds from the
+        # beginning of the session.
+        sig { returns(Integer) }
+        attr_accessor :start_ms
+
+        # The event type, always `session.output_transcript.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # A transcript fragment for assistant output audio in the Live session. Accumulate
+        # fragments in delivery order; these events do not define complete turns or
+        # include a transcript-done event.
+        sig do
+          params(
+
+            delta: String,
+
+            end_ms: Integer,
+
+            event_id: String,
+
+            start_ms: Integer,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The transcript text fragment for the audio in this time range. Append fragments
+          # in delivery order to build the transcript.
+          delta:,
+
+          # The end of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session. For appended context, this can equal start_ms.
+          end_ms:,
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The start of this event on the Live session timeline, in milliseconds from the
+          # beginning of the session.
+          start_ms:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.output_transcript.delta`.
+
+          type: :"session.output_transcript.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: String,
+              end_ms: Integer,
+              event_id: String,
+              start_ms: Integer,
+              type: Symbol,
+              client_event_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/response_create_event.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ResponseCreateEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ResponseCreateEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The Live client event type. Always `response.create`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client identifier for correlating this command with a server event's
+        # client_event_id or error.client_event_id.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :event_id
+
+        # Request a response from the Live session’s Responses backend, or continue a
+        # delegated response waiting for tool results. Requires Responses delegation.
+        sig do
+          params(
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          # The Live client event type. Always `response.create`.
+
+          type: :"response.create"
+        )
+        end
+
+        sig do
+          override.returns(
+            {type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/response_event.rbi

@@ -0,0 +1,105 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ResponseEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ResponseEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The nested Responses streaming event. Dispatch on its type field. Response
+        # lifecycle snapshots omit input and clear instructions, tools, and output to keep
+        # messages small; consume granular output events for the generated content.
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        attr_accessor :event
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, always `response.event`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The event_id of the client command associated with this server event, when
+        # supplied.
+        sig { returns(T.nilable(String)) }
+        attr_reader :client_event_id
+
+        sig { params(client_event_id: String).void }
+        attr_writer :client_event_id
+
+        # The Live delegation associated with the nested Responses event. May be null or
+        # omitted when the event cannot be correlated with a delegation.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :delegation_id
+
+        # A streaming Responses API event from a backend delegated to by the Live session.
+        # Use the outer delegation_id to associate the nested stream with its Live
+        # delegation.
+        sig do
+          params(
+
+            event: T::Hash[Symbol, T.anything],
+
+            event_id: String,
+
+            client_event_id: String,
+
+            delegation_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The nested Responses streaming event. Dispatch on its type field. Response
+          # lifecycle snapshots omit input and clear instructions, tools, and output to keep
+          # messages small; consume granular output events for the generated content.
+          event:,
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The Live delegation associated with the nested Responses event. May be null or
+          # omitted when the event cannot be correlated with a delegation.
+          delegation_id: nil,
+
+          # The event type, always `response.event`.
+
+          type: :"response.event"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event: T::Hash[Symbol, T.anything],
+              event_id: String,
+              type: Symbol,
+              client_event_id: T.nilable(String),
+              delegation_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/response_item_create_event.rbi

@@ -0,0 +1,183 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ResponseItemCreateEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ResponseItemCreateEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # An input item to append to the Responses backend conversation, such as a user
+        # message or a function tool result.
+        sig {
+          returns(
+            T.any(
+              OpenAI::Responses::EasyInputMessage,
+              OpenAI::Responses::ResponseInputItem::Message,
+              OpenAI::Responses::ResponseOutputMessage,
+              OpenAI::Responses::ResponseFileSearchToolCall,
+              OpenAI::Responses::ResponseComputerToolCall,
+              OpenAI::Responses::ResponseInputItem::ComputerCallOutput,
+              OpenAI::Responses::ResponseFunctionWebSearch,
+              OpenAI::Responses::ResponseFunctionToolCall,
+              OpenAI::Responses::ResponseInputItem::FunctionCallOutput,
+              OpenAI::Responses::ResponseInputItem::ToolSearchCall,
+              OpenAI::Responses::ResponseToolSearchOutputItemParam,
+              OpenAI::Responses::ResponseInputItem::AdditionalTools,
+              OpenAI::Responses::ResponseConfigurationUpdateItemParam,
+              OpenAI::Responses::ResponseReasoningItem,
+              OpenAI::Responses::ResponseCompactionItemParam,
+              OpenAI::Responses::ResponseInputItem::ImageGenerationCall,
+              OpenAI::Responses::ResponseCodeInterpreterToolCall,
+              OpenAI::Responses::ResponseInputItem::LocalShellCall,
+              OpenAI::Responses::ResponseInputItem::LocalShellCallOutput,
+              OpenAI::Responses::ResponseInputItem::ShellCall,
+              OpenAI::Responses::ResponseInputItem::ShellCallOutput,
+              OpenAI::Responses::ResponseInputItem::ApplyPatchCall,
+              OpenAI::Responses::ResponseInputItem::ApplyPatchCallOutput,
+              OpenAI::Responses::ResponseInputItem::McpListTools,
+              OpenAI::Responses::ResponseInputItem::McpApprovalRequest,
+              OpenAI::Responses::ResponseInputItem::McpApprovalResponse,
+              OpenAI::Responses::ResponseInputItem::McpCall,
+              OpenAI::Responses::ResponseCustomToolCallOutput,
+              OpenAI::Responses::ResponseCustomToolCall,
+              OpenAI::Responses::ResponseInputItem::CompactionTrigger,
+              OpenAI::Responses::ResponseInputItem::ItemReference,
+              OpenAI::Responses::ResponseInputItem::Program,
+              OpenAI::Responses::ResponseInputItem::ProgramOutput
+            )
+          )
+        }
+        attr_accessor :item
+
+        # The Live client event type. Always `response.item.create`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Optional client identifier for correlating this command with a server event's
+        # client_event_id or error.client_event_id.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :event_id
+
+        # Add an input item to the Live session’s Responses backend. Requires Responses
+        # delegation; use `response.create` to request a response.
+        sig do
+          params(
+
+            item: T.any(
+              OpenAI::Responses::EasyInputMessage::OrHash,
+              OpenAI::Responses::ResponseInputItem::Message::OrHash,
+              OpenAI::Responses::ResponseOutputMessage::OrHash,
+              OpenAI::Responses::ResponseFileSearchToolCall::OrHash,
+              OpenAI::Responses::ResponseComputerToolCall::OrHash,
+              OpenAI::Responses::ResponseInputItem::ComputerCallOutput::OrHash,
+              OpenAI::Responses::ResponseFunctionWebSearch::OrHash,
+              OpenAI::Responses::ResponseFunctionToolCall::OrHash,
+              OpenAI::Responses::ResponseInputItem::FunctionCallOutput::OrHash,
+              OpenAI::Responses::ResponseInputItem::ToolSearchCall::OrHash,
+              OpenAI::Responses::ResponseToolSearchOutputItemParam::OrHash,
+              OpenAI::Responses::ResponseInputItem::AdditionalTools::OrHash,
+              OpenAI::Responses::ResponseConfigurationUpdateItemParam::OrHash,
+              OpenAI::Responses::ResponseReasoningItem::OrHash,
+              OpenAI::Responses::ResponseCompactionItemParam::OrHash,
+              OpenAI::Responses::ResponseInputItem::ImageGenerationCall::OrHash,
+              OpenAI::Responses::ResponseCodeInterpreterToolCall::OrHash,
+              OpenAI::Responses::ResponseInputItem::LocalShellCall::OrHash,
+              OpenAI::Responses::ResponseInputItem::LocalShellCallOutput::OrHash,
+              OpenAI::Responses::ResponseInputItem::ShellCall::OrHash,
+              OpenAI::Responses::ResponseInputItem::ShellCallOutput::OrHash,
+              OpenAI::Responses::ResponseInputItem::ApplyPatchCall::OrHash,
+              OpenAI::Responses::ResponseInputItem::ApplyPatchCallOutput::OrHash,
+              OpenAI::Responses::ResponseInputItem::McpListTools::OrHash,
+              OpenAI::Responses::ResponseInputItem::McpApprovalRequest::OrHash,
+              OpenAI::Responses::ResponseInputItem::McpApprovalResponse::OrHash,
+              OpenAI::Responses::ResponseInputItem::McpCall::OrHash,
+              OpenAI::Responses::ResponseCustomToolCallOutput::OrHash,
+              OpenAI::Responses::ResponseCustomToolCall::OrHash,
+              OpenAI::Responses::ResponseInputItem::CompactionTrigger::OrHash,
+              OpenAI::Responses::ResponseInputItem::ItemReference::OrHash,
+              OpenAI::Responses::ResponseInputItem::Program::OrHash,
+              OpenAI::Responses::ResponseInputItem::ProgramOutput::OrHash
+            ),
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # An input item to append to the Responses backend conversation, such as a user
+          # message or a function tool result.
+          item:,
+
+          # Optional client identifier for correlating this command with a server event's
+          # client_event_id or error.client_event_id.
+          event_id: nil,
+
+          # The Live client event type. Always `response.item.create`.
+
+          type: :"response.item.create"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              item: T.any(
+                OpenAI::Responses::EasyInputMessage,
+                OpenAI::Responses::ResponseInputItem::Message,
+                OpenAI::Responses::ResponseOutputMessage,
+                OpenAI::Responses::ResponseFileSearchToolCall,
+                OpenAI::Responses::ResponseComputerToolCall,
+                OpenAI::Responses::ResponseInputItem::ComputerCallOutput,
+                OpenAI::Responses::ResponseFunctionWebSearch,
+                OpenAI::Responses::ResponseFunctionToolCall,
+                OpenAI::Responses::ResponseInputItem::FunctionCallOutput,
+                OpenAI::Responses::ResponseInputItem::ToolSearchCall,
+                OpenAI::Responses::ResponseToolSearchOutputItemParam,
+                OpenAI::Responses::ResponseInputItem::AdditionalTools,
+                OpenAI::Responses::ResponseConfigurationUpdateItemParam,
+                OpenAI::Responses::ResponseReasoningItem,
+                OpenAI::Responses::ResponseCompactionItemParam,
+                OpenAI::Responses::ResponseInputItem::ImageGenerationCall,
+                OpenAI::Responses::ResponseCodeInterpreterToolCall,
+                OpenAI::Responses::ResponseInputItem::LocalShellCall,
+                OpenAI::Responses::ResponseInputItem::LocalShellCallOutput,
+                OpenAI::Responses::ResponseInputItem::ShellCall,
+                OpenAI::Responses::ResponseInputItem::ShellCallOutput,
+                OpenAI::Responses::ResponseInputItem::ApplyPatchCall,
+                OpenAI::Responses::ResponseInputItem::ApplyPatchCallOutput,
+                OpenAI::Responses::ResponseInputItem::McpListTools,
+                OpenAI::Responses::ResponseInputItem::McpApprovalRequest,
+                OpenAI::Responses::ResponseInputItem::McpApprovalResponse,
+                OpenAI::Responses::ResponseInputItem::McpCall,
+                OpenAI::Responses::ResponseCustomToolCallOutput,
+                OpenAI::Responses::ResponseCustomToolCall,
+                OpenAI::Responses::ResponseInputItem::CompactionTrigger,
+                OpenAI::Responses::ResponseInputItem::ItemReference,
+                OpenAI::Responses::ResponseInputItem::Program,
+                OpenAI::Responses::ResponseInputItem::ProgramOutput
+              ),
+              type: Symbol,
+              event_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end