openai 0.88.0 → 0.89.0

data/lib/openai/models/live/error_event.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class ErrorEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute error
+        #   Details of the Live error and the client command that caused it, when known.
+        #
+        #   @return [OpenAI::Models::Live::Error]
+        required :error, -> { OpenAI::Live::Error }
+
+        # @!attribute event_id
+        #   The unique ID of the Live server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute type
+        #   The event type, always `error`.
+        #
+        #   @return [Symbol, :error]
+        required :type, const: :error
+
+        # @!attribute client_event_id
+        #   The event_id of the client command associated with this server event, when
+        #   supplied.
+        #
+        #   @return [String, nil]
+        optional :client_event_id, String
+
+        # @!method initialize(error:, event_id:, client_event_id: nil, type: :error)
+        #   Reports an error in the Live session, such as an invalid client command. Use
+        #   error.client_event_id, when present, to identify the command that caused the
+        #   error.
+        #
+        #   @param error [OpenAI::Models::Live::Error]
+        #     Details of the Live error and the client command that caused it, when known.
+        #
+        #   @param event_id [String]
+        #     The unique ID of the Live server event.
+        #
+        #   @param client_event_id [String]
+        #     The event_id of the client command associated with this server event, when
+        #     supplied.
+        #
+        #   @param type [Symbol, :error]
+        #     The event type, always `error`.
+      end
+    end
+  end
+end

data/lib/openai/models/live/fork_client_event.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      # Client events for a Live fork WebSocket. First send session.start with an
+      # overrides object (which may be empty), then wait for session.started before
+      # sending other commands. The model and conversation are inherited from the stored
+      # session.
+      module ForkClientEvent
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # Start a Live session after connecting to a stored session’s fork WebSocket. Send an empty `session` object to use the stored configuration.
+        variant :"session.start", -> { OpenAI::Live::ForkSessionStartEvent }
+
+        # Update the delegation settings of an active Live session. The server acknowledges accepted changes with `session.updated`.
+        variant :"session.update", -> { OpenAI::Live::SessionUpdateEvent }
+
+        # Send audio to a Live session over its primary WebSocket. WebRTC and SIP sessions send audio over their media transport.
+        variant :"session.input_audio.append", -> { OpenAI::Live::InputAudioAppendEvent }
+
+        # Mute audio input to the Live model without closing the session. The server acknowledges with `session.input_audio.muted`.
+        variant :"session.input_audio.mute", -> { OpenAI::Live::InputAudioMuteEvent }
+
+        # Resume audio input to a Live model after muting it. The server acknowledges with `session.input_audio.unmuted`.
+        variant :"session.input_audio.unmute", -> { OpenAI::Live::InputAudioUnmuteEvent }
+
+        # Append instructions to the Live conversation while it is running, optionally associating them with an existing client delegation.
+        variant :"session.instructions.append", -> { OpenAI::Live::InstructionsAppendEvent }
+
+        # Provide silent reasoning or progress context to the Live model, optionally for an existing client delegation.
+        variant :"session.thinking.append", -> { OpenAI::Live::ThinkingAppendEvent }
+
+        # Provide context the Live model can communicate to the user, optionally for an existing client delegation.
+        variant :"session.commentary.append", -> { OpenAI::Live::CommentaryAppendEvent }
+
+        # Add an input item to the Live session’s Responses backend. Requires Responses delegation; use `response.create` to request a response.
+        variant :"response.item.create", -> { OpenAI::Live::ResponseItemCreateEvent }
+
+        # Request a response from the Live session’s Responses backend, or continue a delegated response waiting for tool results. Requires Responses delegation.
+        variant :"response.create", -> { OpenAI::Live::ResponseCreateEvent }
+
+        # Request that the Live session close. The terminal `session.closed` event contains the close reason and final usage.
+        variant :"session.close", -> { OpenAI::Live::SessionCloseEvent }
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Live::ForkSessionStartEvent, OpenAI::Models::Live::SessionUpdateEvent, OpenAI::Models::Live::InputAudioAppendEvent, OpenAI::Models::Live::InputAudioMuteEvent, OpenAI::Models::Live::InputAudioUnmuteEvent, OpenAI::Models::Live::InstructionsAppendEvent, OpenAI::Models::Live::ThinkingAppendEvent, OpenAI::Models::Live::CommentaryAppendEvent, OpenAI::Models::Live::ResponseItemCreateEvent, OpenAI::Models::Live::ResponseCreateEvent, OpenAI::Models::Live::SessionCloseEvent)]
+      end
+    end
+  end
+end

data/lib/openai/models/live/fork_server_event.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      # Server events for Live. Response lifecycle events are wrapped inside
+      # response.event; dispatch the nested event by its full type and tolerate new
+      # response event types. Follow the
+      # [Live prompting guide](https://developers.openai.com/api/docs/guides/live-prompting)
+      # when designing the conversation and delegation policy.
+      module ForkServerEvent
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # Returned when a Live session has started. Contains the resolved session configuration, including server defaults.
+        variant :"session.started", -> { OpenAI::Live::SessionStartedEvent }
+
+        # Returned when a Live session update is accepted. Contains the resolved session configuration after the update.
+        variant :"session.updated", -> { OpenAI::Live::SessionUpdatedEvent }
+
+        # Returned when a session.input_audio.mute command is accepted. Input audio is no longer sent to the model; sideband audio reflection continues.
+        variant :"session.input_audio.muted", -> { OpenAI::Live::InputAudioMutedEvent }
+
+        # Returned when a session.input_audio.unmute command is accepted. Input audio is sent to the model again.
+        variant :"session.input_audio.unmuted", -> { OpenAI::Live::InputAudioUnmutedEvent }
+
+        # Returned when a session.instructions.append command is accepted into the Live session timeline. Acknowledges the appended instructions without guaranteeing that the model has acted on them.
+        variant :"session.instructions.appended", -> { OpenAI::Live::InstructionsAppendedEvent }
+
+        # Returned when a session.thinking.append command is accepted into the Live session timeline. Acknowledges the added reasoning context without guaranteeing any spoken output.
+        variant :"session.thinking.appended", -> { OpenAI::Live::ThinkingAppendedEvent }
+
+        # Returned when a session.commentary.append command is accepted into the Live session timeline. Acknowledges the added commentary without guaranteeing exact wording or completed audio playback.
+        variant :"session.commentary.appended", -> { OpenAI::Live::CommentaryAppendedEvent }
+
+        # Input audio received from the primary transport and reflected to a Live sideband connection before model-input muting.
+        variant :"session.input_audio.append", -> { OpenAI::Live::ForkServerEvent::SessionInputAudioAppend }
+
+        # 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.
+        variant :"session.output_audio.delta", -> { OpenAI::Live::OutputAudioDeltaEvent }
+
+        # A transcript fragment for user input audio in the Live session. Accumulate fragments in delivery order; these events do not define complete turns or include a transcript-done event.
+        variant :"session.input_transcript.delta", -> { OpenAI::Live::InputTranscriptDeltaEvent }
+
+        # 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.
+        variant :"session.output_transcript.delta", -> { OpenAI::Live::OutputTranscriptDeltaEvent }
+
+        # Returned when the Live model delegates work to your application or a Responses backend. Contains delegation metadata and the position on the session timeline where the work was delegated.
+        variant :"session.delegation.created", -> { OpenAI::Live::DelegationCreatedEvent }
+
+        # 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.
+        variant :"response.event", -> { OpenAI::Live::ResponseEvent }
+
+        # Reports cumulative Live audio usage and, when available, the most recent context-window usage. Delegated Responses token usage is reported separately in response.event events.
+        variant :"session.usage.updated", -> { OpenAI::Live::SessionUsageUpdatedEvent }
+
+        # Returned after the Live session finishes finalizing, with the close reason, final session snapshot, and cumulative audio usage. A connection closing without this event does not confirm successful finalization.
+        variant :"session.closed", -> { OpenAI::Live::SessionClosedEvent }
+
+        # Reports an error in the Live session, such as an invalid client command. Use error.client_event_id, when present, to identify the command that caused the error.
+        variant :error, -> { OpenAI::Live::ErrorEvent }
+
+        # An informational notice about the Live session, such as the event permissions applied to a frontend data channel.
+        variant :info, -> { OpenAI::Live::InfoEvent }
+
+        # A SIP DTMF keypress received from the caller. Delivered only to sideband observers.
+        variant :"transport.dtmf.received", -> { OpenAI::Live::ForkServerEvent::TransportDtmfReceived }
+
+        # A SIP DTMF keypress successfully sent by the hosted tool. Delivered only to sideband observers; this is not a client command.
+        variant :"transport.dtmf.send", -> { OpenAI::Live::ForkServerEvent::TransportDtmfSend }
+
+        # The outbound SIP provider leg is ringing or providing early media. Delivered only to sideband observers.
+        variant :"transport.ringing", -> { OpenAI::Live::ForkServerEvent::TransportRinging }
+
+        # The outbound SIP provider leg answered and media is established. Delivered only to sideband observers.
+        variant :"transport.answered", -> { OpenAI::Live::ForkServerEvent::TransportAnswered }
+
+        # An asynchronous outbound SIP setup failure. Delivered only to sideband observers.
+        variant :"transport.failed", -> { OpenAI::Live::ForkServerEvent::TransportFailed }
+
+        class SessionInputAudioAppend < OpenAI::Internal::Type::BaseModel
+          # @!attribute audio
+          #   Base64-encoded raw mono PCM16LE at 24 kHz received from the primary transport,
+          #   reflected to the sideband before model-input muting. This server event uses the
+          #   same audio key as the client command, but is not an acknowledgment of it.
+          #
+          #   @return [String]
+          required :audio, String
+
+          # @!attribute type
+          #   The event type, always `session.input_audio.append`.
+          #
+          #   @return [Symbol, :"session.input_audio.append"]
+          required :type, const: :"session.input_audio.append"
+
+          # @!method initialize(audio:, type: :"session.input_audio.append")
+          #   Input audio received from the primary transport and reflected to a Live sideband
+          #   connection before model-input muting.
+          #
+          #   @param audio [String]
+          #     Base64-encoded raw mono PCM16LE at 24 kHz received from the primary transport,
+          #     reflected to the sideband before model-input muting. This server event uses the
+          #     same audio key as the client command, but is not an acknowledgment of it.
+          #
+          #   @param type [Symbol, :"session.input_audio.append"]
+          #     The event type, always `session.input_audio.append`.
+        end
+
+        class TransportDtmfReceived < OpenAI::Internal::Type::BaseModel
+          # @!attribute event
+          #
+          #   @return [String]
+          required :event, String
+
+          # @!attribute event_id
+          #
+          #   @return [String]
+          required :event_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :"transport.dtmf.received"]
+          required :type, const: :"transport.dtmf.received"
+
+          # @!method initialize(event:, event_id:, type: :"transport.dtmf.received")
+          #   A SIP DTMF keypress received from the caller. Delivered only to sideband
+          #   observers.
+          #
+          #   @param event [String]
+          #   @param event_id [String]
+          #   @param type [Symbol, :"transport.dtmf.received"]
+        end
+
+        class TransportDtmfSend < OpenAI::Internal::Type::BaseModel
+          # @!attribute event
+          #
+          #   @return [String]
+          required :event, String
+
+          # @!attribute event_id
+          #
+          #   @return [String]
+          required :event_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :"transport.dtmf.send"]
+          required :type, const: :"transport.dtmf.send"
+
+          # @!method initialize(event:, event_id:, type: :"transport.dtmf.send")
+          #   A SIP DTMF keypress successfully sent by the hosted tool. Delivered only to
+          #   sideband observers; this is not a client command.
+          #
+          #   @param event [String]
+          #   @param event_id [String]
+          #   @param type [Symbol, :"transport.dtmf.send"]
+        end
+
+        class TransportRinging < OpenAI::Internal::Type::BaseModel
+          # @!attribute event_id
+          #
+          #   @return [String]
+          required :event_id, String
+
+          # @!attribute session_id
+          #   The canonical Live session ID.
+          #
+          #   @return [String]
+          required :session_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :"transport.ringing"]
+          required :type, const: :"transport.ringing"
+
+          # @!method initialize(event_id:, session_id:, type: :"transport.ringing")
+          #   The outbound SIP provider leg is ringing or providing early media. Delivered
+          #   only to sideband observers.
+          #
+          #   @param event_id [String]
+          #
+          #   @param session_id [String]
+          #     The canonical Live session ID.
+          #
+          #   @param type [Symbol, :"transport.ringing"]
+        end
+
+        class TransportAnswered < OpenAI::Internal::Type::BaseModel
+          # @!attribute event_id
+          #
+          #   @return [String]
+          required :event_id, String
+
+          # @!attribute session_id
+          #   The canonical Live session ID.
+          #
+          #   @return [String]
+          required :session_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :"transport.answered"]
+          required :type, const: :"transport.answered"
+
+          # @!method initialize(event_id:, session_id:, type: :"transport.answered")
+          #   The outbound SIP provider leg answered and media is established. Delivered only
+          #   to sideband observers.
+          #
+          #   @param event_id [String]
+          #
+          #   @param session_id [String]
+          #     The canonical Live session ID.
+          #
+          #   @param type [Symbol, :"transport.answered"]
+        end
+
+        class TransportFailed < OpenAI::Internal::Type::BaseModel
+          # @!attribute error
+          #
+          #   @return [OpenAI::Models::Live::ForkServerEvent::TransportFailed::Error]
+          required :error, -> { OpenAI::Live::ForkServerEvent::TransportFailed::Error }
+
+          # @!attribute event_id
+          #
+          #   @return [String]
+          required :event_id, String
+
+          # @!attribute session_id
+          #   The canonical Live session ID.
+          #
+          #   @return [String]
+          required :session_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :"transport.failed"]
+          required :type, const: :"transport.failed"
+
+          # @!method initialize(error:, event_id:, session_id:, type: :"transport.failed")
+          #   An asynchronous outbound SIP setup failure. Delivered only to sideband
+          #   observers.
+          #
+          #   @param error [OpenAI::Models::Live::ForkServerEvent::TransportFailed::Error]
+          #
+          #   @param event_id [String]
+          #
+          #   @param session_id [String]
+          #     The canonical Live session ID.
+          #
+          #   @param type [Symbol, :"transport.failed"]
+
+          # @see OpenAI::Models::Live::ForkServerEvent::TransportFailed#error
+          class Error < OpenAI::Internal::Type::BaseModel
+            # @!attribute code
+            #   The call setup failure code.
+            #
+            #   @return [String]
+            required :code, String
+
+            # @!attribute message
+            #
+            #   @return [String]
+            required :message, String
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :call_error]
+            required :type, const: :call_error
+
+            # @!attribute param
+            #   The parameter related to the error, if any. Empty when no parameter applies.
+            #
+            #   @return [String, nil]
+            optional :param, String
+
+            # @!method initialize(code:, message:, param: nil, type: :call_error)
+            #   @param code [String]
+            #     The call setup failure code.
+            #
+            #   @param message [String]
+            #
+            #   @param param [String]
+            #     The parameter related to the error, if any. Empty when no parameter applies.
+            #
+            #   @param type [Symbol, :call_error]
+          end
+        end
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Live::SessionStartedEvent, OpenAI::Models::Live::SessionUpdatedEvent, OpenAI::Models::Live::InputAudioMutedEvent, OpenAI::Models::Live::InputAudioUnmutedEvent, OpenAI::Models::Live::InstructionsAppendedEvent, OpenAI::Models::Live::ThinkingAppendedEvent, OpenAI::Models::Live::CommentaryAppendedEvent, OpenAI::Models::Live::ForkServerEvent::SessionInputAudioAppend, OpenAI::Models::Live::OutputAudioDeltaEvent, OpenAI::Models::Live::InputTranscriptDeltaEvent, OpenAI::Models::Live::OutputTranscriptDeltaEvent, OpenAI::Models::Live::DelegationCreatedEvent, OpenAI::Models::Live::ResponseEvent, OpenAI::Models::Live::SessionUsageUpdatedEvent, OpenAI::Models::Live::SessionClosedEvent, OpenAI::Models::Live::ErrorEvent, OpenAI::Models::Live::InfoEvent, OpenAI::Models::Live::ForkServerEvent::TransportDtmfReceived, OpenAI::Models::Live::ForkServerEvent::TransportDtmfSend, OpenAI::Models::Live::ForkServerEvent::TransportRinging, OpenAI::Models::Live::ForkServerEvent::TransportAnswered, OpenAI::Models::Live::ForkServerEvent::TransportFailed)]
+      end
+    end
+  end
+end

data/lib/openai/models/live/fork_session_config.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class ForkSessionConfig < OpenAI::Internal::Type::BaseModel
+        # @!attribute audio
+        #   Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+        #   must omit this field.
+        #
+        #   @return [OpenAI::Models::Live::ForkSessionConfig::Audio, nil]
+        optional :audio, -> { OpenAI::Live::ForkSessionConfig::Audio }
+
+        # @!attribute client
+        #   Frontend data-channel permissions for a WebRTC fork. Omitted permissions inherit
+        #   the stored values. Not supported for WebSocket forks.
+        #
+        #   @return [OpenAI::Models::Live::ClientConfig, nil]
+        optional :client, -> { OpenAI::Live::ClientConfig }
+
+        # @!attribute delegation
+        #   Overrides for the stored session’s Responses backend. Only supported when the
+        #   stored session already uses Responses delegation; the delegation type cannot
+        #   change.
+        #
+        #   @return [OpenAI::Models::Live::ForkSessionConfig::Delegation, nil]
+        optional :delegation, -> { OpenAI::Live::ForkSessionConfig::Delegation }
+
+        # @!attribute store
+        #   Whether to store the forked session. Omission inherits the stored session's
+        #   setting.
+        #
+        #   @return [Boolean, nil]
+        optional :store, OpenAI::Internal::Type::Boolean
+
+        # @!method initialize(audio: nil, client: nil, delegation: nil, store: nil)
+        #   Overrides for a stored session after connecting to the fork WebSocket. An empty
+        #   object inherits the stored configuration; do not supply a new model.
+        #   audio.format applies only to the new WebSocket connection. client overrides are
+        #   only supported for WebRTC forks.
+        #
+        #   @param audio [OpenAI::Models::Live::ForkSessionConfig::Audio]
+        #     Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+        #     must omit this field.
+        #
+        #   @param client [OpenAI::Models::Live::ClientConfig]
+        #     Frontend data-channel permissions for a WebRTC fork. Omitted permissions inherit
+        #     the stored values. Not supported for WebSocket forks.
+        #
+        #   @param delegation [OpenAI::Models::Live::ForkSessionConfig::Delegation]
+        #     Overrides for the stored session’s Responses backend. Only supported when the
+        #     stored session already uses Responses delegation; the delegation type cannot
+        #     change.
+        #
+        #   @param store [Boolean]
+        #     Whether to store the forked session. Omission inherits the stored session's
+        #     setting.
+
+        # @see OpenAI::Models::Live::ForkSessionConfig#audio
+        class Audio < OpenAI::Internal::Type::BaseModel
+          # @!attribute format_
+          #   Audio encoding and sample rate for audio sent and received over a Live WebSocket
+          #   connection. WebRTC and SIP negotiate their media format separately.
+          #
+          #   @return [OpenAI::Models::Live::AudioFormat::AudioPCM, OpenAI::Models::Live::AudioFormat::AudioPCMU, OpenAI::Models::Live::AudioFormat::AudioPCMA, nil]
+          optional :format_, union: -> { OpenAI::Live::AudioFormat }, api_name: :format
+
+          # @!method initialize(format_: nil)
+          #   Audio format for a WebSocket fork. WebRTC forks negotiate their audio format and
+          #   must omit this field.
+          #
+          #   @param format_ [OpenAI::Models::Live::AudioFormat::AudioPCM, OpenAI::Models::Live::AudioFormat::AudioPCMU, OpenAI::Models::Live::AudioFormat::AudioPCMA]
+          #     Audio encoding and sample rate for audio sent and received over a Live WebSocket
+          #     connection. WebRTC and SIP negotiate their media format separately.
+        end
+
+        # @see OpenAI::Models::Live::ForkSessionConfig#delegation
+        class Delegation < OpenAI::Internal::Type::BaseModel
+          # @!attribute type
+          #   The delegation owner. Always `responses` for tasks handled by the Responses API.
+          #
+          #   @return [Symbol, :responses]
+          required :type, const: :responses
+
+          # @!attribute responses
+          #   Responses backend settings to update. Omitted settings keep their existing
+          #   values.
+          #
+          #   @return [OpenAI::Models::Live::ResponsesDelegationUpdateConfig, nil]
+          optional :responses, -> { OpenAI::Live::ResponsesDelegationUpdateConfig }
+
+          # @!method initialize(responses: nil, type: :responses)
+          #   Overrides for the stored session’s Responses backend. Only supported when the
+          #   stored session already uses Responses delegation; the delegation type cannot
+          #   change.
+          #
+          #   @param responses [OpenAI::Models::Live::ResponsesDelegationUpdateConfig]
+          #     Responses backend settings to update. Omitted settings keep their existing
+          #     values.
+          #
+          #   @param type [Symbol, :responses]
+          #     The delegation owner. Always `responses` for tasks handled by the Responses API.
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/live/fork_session_start_event.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class ForkSessionStartEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute session
+        #   Overrides for a stored session after connecting to the fork WebSocket. An empty
+        #   object inherits the stored configuration; do not supply a new model.
+        #   audio.format applies only to the new WebSocket connection. client overrides are
+        #   only supported for WebRTC forks.
+        #
+        #   @return [OpenAI::Models::Live::ForkSessionConfig]
+        required :session, -> { OpenAI::Live::ForkSessionConfig }
+
+        # @!attribute type
+        #   The Live client event type. Always `session.start`.
+        #
+        #   @return [Symbol, :"session.start"]
+        required :type, const: :"session.start"
+
+        # @!attribute event_id
+        #   Optional client identifier for correlating this command with a server event's
+        #   client_event_id or error.client_event_id.
+        #
+        #   @return [String, nil]
+        optional :event_id, String, nil?: true
+
+        # @!method initialize(session:, event_id: nil, type: :"session.start")
+        #   Start a Live session after connecting to a stored session’s fork WebSocket. Send
+        #   an empty `session` object to use the stored configuration.
+        #
+        #   @param session [OpenAI::Models::Live::ForkSessionConfig]
+        #     Overrides for a stored session after connecting to the fork WebSocket. An empty
+        #     object inherits the stored configuration; do not supply a new model.
+        #     audio.format applies only to the new WebSocket connection. client overrides are
+        #     only supported for WebRTC forks.
+        #
+        #   @param event_id [String, nil]
+        #     Optional client identifier for correlating this command with a server event's
+        #     client_event_id or error.client_event_id.
+        #
+        #   @param type [Symbol, :"session.start"]
+        #     The Live client event type. Always `session.start`.
+      end
+    end
+  end
+end

data/lib/openai/models/live/function_tool.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class FunctionTool < OpenAI::Internal::Type::BaseModel
+        # @!attribute name
+        #   The name the delegated Responses model uses when calling this function.
+        #
+        #   @return [String]
+        required :name, String
+
+        # @!attribute type
+        #   The tool type. Always `function`.
+        #
+        #   @return [Symbol, :function]
+        required :type, const: :function
+
+        # @!attribute description
+        #   What the function does and when the delegated Responses model should call it.
+        #
+        #   @return [String, nil]
+        optional :description, String, nil?: true
+
+        # @!attribute parameters
+        #   A JSON Schema object describing the arguments accepted by the function.
+        #
+        #   @return [Hash{Symbol=>Object}, nil]
+        optional :parameters, OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown], nil?: true
+
+        # @!attribute strict
+        #   Whether the delegated Responses model must follow the function’s parameter
+        #   schema exactly.
+        #
+        #   @return [Boolean, nil]
+        optional :strict, OpenAI::Internal::Type::Boolean, nil?: true
+
+        # @!method initialize(name:, description: nil, parameters: nil, strict: nil, type: :function)
+        #   A function tool available to the Responses backend when the Live model delegates
+        #   a task.
+        #
+        #   @param name [String]
+        #     The name the delegated Responses model uses when calling this function.
+        #
+        #   @param description [String, nil]
+        #     What the function does and when the delegated Responses model should call it.
+        #
+        #   @param parameters [Hash{Symbol=>Object}, nil]
+        #     A JSON Schema object describing the arguments accepted by the function.
+        #
+        #   @param strict [Boolean, nil]
+        #     Whether the delegated Responses model must follow the function’s parameter
+        #     schema exactly.
+        #
+        #   @param type [Symbol, :function]
+        #     The tool type. Always `function`.
+      end
+    end
+  end
+end

data/lib/openai/models/live/info_event.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Live
+      class InfoEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute code
+        #   A machine-readable code for the notice, such as `data_channel_permissions`.
+        #
+        #   @return [String]
+        required :code, String
+
+        # @!attribute event_id
+        #   The unique ID of the Live server event.
+        #
+        #   @return [String]
+        required :event_id, String
+
+        # @!attribute message
+        #   A human-readable explanation of the Live session notice.
+        #
+        #   @return [String]
+        required :message, String
+
+        # @!attribute type
+        #   The event type, always `info`.
+        #
+        #   @return [Symbol, :info]
+        required :type, const: :info
+
+        # @!attribute client_event_id
+        #   The event_id of the client command associated with this server event, when
+        #   supplied.
+        #
+        #   @return [String, nil]
+        optional :client_event_id, String
+
+        # @!method initialize(code:, event_id:, message:, client_event_id: nil, type: :info)
+        #   An informational notice about the Live session, such as the event permissions
+        #   applied to a frontend data channel.
+        #
+        #   @param code [String]
+        #     A machine-readable code for the notice, such as `data_channel_permissions`.
+        #
+        #   @param event_id [String]
+        #     The unique ID of the Live server event.
+        #
+        #   @param message [String]
+        #     A human-readable explanation of the Live session notice.
+        #
+        #   @param client_event_id [String]
+        #     The event_id of the client command associated with this server event, when
+        #     supplied.
+        #
+        #   @param type [Symbol, :info]
+        #     The event type, always `info`.
+      end
+    end
+  end
+end