openai 0.88.0 → 0.89.0

data/rbi/openai/models/live/session_update_config.rbi

@@ -0,0 +1,134 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class SessionUpdateConfig < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionUpdateConfig,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Delegation settings to update. The delegation type must match the current
+        # session; omitted settings retain their values.
+        sig {
+          returns(
+            T.nilable(T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionUpdateConfig::Delegation::Responses))
+          )
+        }
+        attr_accessor :delegation
+
+        # Changes to an active Live session. Only delegation backend settings can be
+        # updated after startup.
+        sig do
+          params(
+
+            delegation: T.nilable(
+              T.any(
+                OpenAI::Live::ClientDelegation::OrHash,
+                OpenAI::Live::SessionUpdateConfig::Delegation::Responses::OrHash
+              )
+            )
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Delegation settings to update. The delegation type must match the current
+          # session; omitted settings retain their values.
+
+          delegation: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delegation: T.nilable(
+                T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionUpdateConfig::Delegation::Responses)
+              )
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Delegation settings to update. The delegation type must match the current
+        # session; omitted settings retain their values.
+        module Delegation
+          extend OpenAI::Internal::Type::Union
+
+          Variants = T.type_alias {
+            T.any(OpenAI::Live::ClientDelegation, OpenAI::Live::SessionUpdateConfig::Delegation::Responses)
+          }
+
+          class Responses < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Live::SessionUpdateConfig::Delegation::Responses,
+                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
+
+          sig { override.returns(T::Array[OpenAI::Live::SessionUpdateConfig::Delegation::Variants]) }
+          def self.variants
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/session_update_event.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class SessionUpdateEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionUpdateEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Sparse delegation updates. Omitted settings retain their values. The delegation
+        # type cannot change, including resetting Responses delegation to null or client.
+        # Model, frontend instructions, audio, and startup input are immutable.
+        sig { returns(OpenAI::Live::SessionUpdateConfig) }
+        attr_reader :session
+
+        sig { params(session: OpenAI::Live::SessionUpdateConfig::OrHash).void }
+        attr_writer :session
+
+        # The Live client event type. Always `session.update`.
+        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
+
+        # Update the delegation settings of an active Live session. The server
+        # acknowledges accepted changes with `session.updated`.
+        sig do
+          params(
+
+            session: OpenAI::Live::SessionUpdateConfig::OrHash,
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Sparse delegation updates. Omitted settings retain their values. The delegation
+          # type cannot change, including resetting Responses delegation to null or client.
+          # Model, frontend instructions, audio, and startup input are immutable.
+          session:,
+
+          # 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 `session.update`.
+
+          type: :"session.update"
+        )
+        end
+
+        sig do
+          override.returns(
+            {session: OpenAI::Live::SessionUpdateConfig, type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/session_updated_event.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class SessionUpdatedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionUpdatedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The resolved Live session configuration and server-assigned session metadata.
+        sig { returns(OpenAI::Live::SessionResource) }
+        attr_reader :session
+
+        sig { params(session: OpenAI::Live::SessionResource::OrHash).void }
+        attr_writer :session
+
+        # The event type, always `session.updated`.
+        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
+
+        # Returned when a Live session update is accepted. Contains the resolved session
+        # configuration after the update.
+        sig do
+          params(
+
+            event_id: String,
+
+            session: OpenAI::Live::SessionResource::OrHash,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The resolved Live session configuration and server-assigned session metadata.
+          session:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The event type, always `session.updated`.
+
+          type: :"session.updated"
+        )
+        end
+
+        sig do
+          override.returns(
+            {event_id: String, session: OpenAI::Live::SessionResource, type: Symbol, client_event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/session_usage.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class SessionUsage < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionUsage,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The cumulative Live audio duration in seconds. Do not sum this value across
+        # usage events.
+        sig { returns(Float) }
+        attr_accessor :seconds
+
+        # Cumulative audio duration for a Live session. Values are totals for the session,
+        # not increments to sum across usage events.
+        sig do
+          params(
+
+            seconds: Float
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The cumulative Live audio duration in seconds. Do not sum this value across
+          # usage events.
+
+          seconds:
+        )
+        end
+
+        sig do
+          override.returns(
+            {seconds: Float}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/session_usage_updated_event.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class SessionUsageUpdatedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionUsageUpdatedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The unique ID of the Live server event.
+        sig { returns(String) }
+        attr_accessor :event_id
+
+        # The event type, always `session.usage.updated`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The cumulative Live audio usage so far.
+        sig { returns(OpenAI::Live::SessionUsage) }
+        attr_reader :usage
+
+        sig { params(usage: OpenAI::Live::SessionUsage::OrHash).void }
+        attr_writer :usage
+
+        # 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 latest measured Live context-window usage. Omitted when the context limit is
+        # unknown.
+        sig { returns(T.nilable(OpenAI::Live::SessionUsageUpdatedEvent::ContextWindow)) }
+        attr_reader :context_window
+
+        sig { params(context_window: OpenAI::Live::SessionUsageUpdatedEvent::ContextWindow::OrHash).void }
+        attr_writer :context_window
+
+        # 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.
+        sig do
+          params(
+
+            event_id: String,
+
+            usage: OpenAI::Live::SessionUsage::OrHash,
+
+            client_event_id: String,
+
+            context_window: OpenAI::Live::SessionUsageUpdatedEvent::ContextWindow::OrHash,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The unique ID of the Live server event.
+          event_id:,
+
+          # The cumulative Live audio usage so far.
+          usage:,
+
+          # The event_id of the client command associated with this server event, when
+          # supplied.
+          client_event_id: nil,
+
+          # The latest measured Live context-window usage. Omitted when the context limit is
+          # unknown.
+          context_window: nil,
+
+          # The event type, always `session.usage.updated`.
+
+          type: :"session.usage.updated"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              event_id: String,
+              type: Symbol,
+              usage: OpenAI::Live::SessionUsage,
+              client_event_id: T.nilable(String),
+              context_window: T.nilable(OpenAI::Live::SessionUsageUpdatedEvent::ContextWindow)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ContextWindow < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Live::SessionUsageUpdatedEvent::ContextWindow,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The latest active context token count divided by the Live model context limit.
+          # Can decrease after compaction and may lag between measured audio frames.
+          sig { returns(Float) }
+          attr_accessor :usage_ratio
+
+          # The latest measured Live context-window usage. Omitted when the context limit is
+          # unknown.
+          sig do
+            params(
+
+              usage_ratio: Float
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The latest active context token count divided by the Live model context limit.
+            # Can decrease after compaction and may lag between measured audio frames.
+
+            usage_ratio:
+          )
+          end
+
+          sig do
+            override.returns(
+              {usage_ratio: Float}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/thinking_append_event.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ThinkingAppendEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ThinkingAppendEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # Silent reasoning or progress context, limited to 500 tokens. It does not
+        # directly request speech, but can influence later speech and is not a secrecy
+        # boundary.
+        sig { returns(String) }
+        attr_accessor :content
+
+        # Required, nullable. Set null for general session context, or use the ID from
+        # session.delegation.created for an existing client delegation. Non-null IDs are
+        # not accepted with Responses delegation.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :delegation_id
+
+        # The Live client event type. Always `session.thinking.append`.
+        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
+
+        # Provide silent reasoning or progress context to the Live model, optionally for
+        # an existing client delegation.
+        sig do
+          params(
+
+            content: String,
+
+            delegation_id: T.nilable(String),
+
+            event_id: T.nilable(String),
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # Silent reasoning or progress context, limited to 500 tokens. It does not
+          # directly request speech, but can influence later speech and is not a secrecy
+          # boundary.
+          content:,
+
+          # Required, nullable. Set null for general session context, or use the ID from
+          # session.delegation.created for an existing client delegation. Non-null IDs are
+          # not accepted with Responses delegation.
+          delegation_id:,
+
+          # 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 `session.thinking.append`.
+
+          type: :"session.thinking.append"
+        )
+        end
+
+        sig do
+          override.returns(
+            {content: String, delegation_id: T.nilable(String), type: Symbol, event_id: T.nilable(String)}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/live/thinking_appended_event.rbi

@@ -0,0 +1,97 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Live
+
+      class ThinkingAppendedEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Live::ThinkingAppendedEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # 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.thinking.appended`.
+        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
+
+        # Returned when a session.thinking.append command is accepted into the Live
+        # session timeline. Acknowledges the added reasoning context without guaranteeing
+        # any spoken output.
+        sig do
+          params(
+
+            end_ms: Integer,
+
+            event_id: String,
+
+            start_ms: Integer,
+
+            client_event_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # 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.thinking.appended`.
+
+          type: :"session.thinking.appended"
+        )
+        end
+
+        sig do
+          override.returns(
+            {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