openai 0.95.0 → 0.96.0

data/rbi/openai/helpers/live/websocket.rbi

@@ -0,0 +1,299 @@
+# typed: strong
+
+module OpenAI
+  class Client < OpenAI::Internal::Transport::BaseClient
+    # @api private
+    sig do
+      params(
+        path: T.any(String, T::Array[String]),
+        query: T::Hash[String, String],
+        websocket_base_url: T.nilable(String),
+        options: T.nilable(OpenAI::RequestOptions::OrHash),
+        block: T
+          .proc
+          .params(
+            request: OpenAI::Internal::Transport::BaseClient::RequestInput,
+            mark_handshake_completed: T.proc.void
+          )
+          .returns(T.anything)
+      )
+        .returns(T.anything)
+    end
+    def with_live_websocket_connection_request(
+      path: "live/sessions",
+      query: {},
+      websocket_base_url: nil,
+      options: nil,
+      &block
+    )
+    end
+  end
+
+  module Errors
+    class LiveConnectionError < OpenAI::Errors::WebSocketConnectionError
+    end
+
+    class LiveProtocolError < OpenAI::Errors::WebSocketProtocolError
+      sig { returns(T.attached_class) }
+      def self.new
+      end
+    end
+  end
+
+  module Models
+    module Live
+      class UnknownServerEvent
+        sig { returns(Symbol) }
+        attr_reader :type
+        sig { returns(T::Hash[T.any(String, Symbol), T.anything]) }
+        attr_reader :data
+        sig { params(data: T::Hash[T.any(String, Symbol), T.anything]).returns(T.attached_class) }
+        def self.new(data:)
+        end
+
+        sig { returns(T::Hash[T.any(String, Symbol), T.anything]) }
+        def to_h
+        end
+
+        sig { returns(String) }
+        def inspect
+        end
+
+        alias to_s inspect
+      end
+
+      class Connection
+        include Enumerable
+        ServerEvent = T.type_alias { T.any(OpenAI::Live::ServerEvent::Variants, OpenAI::Live::UnknownServerEvent) }
+        ClientEvent = T.type_alias do
+          T.any(OpenAI::Live::ClientEvent::Variants, T::Hash[T.any(String, Symbol), T.anything])
+        end
+
+        Elem = type_member { {fixed: ServerEvent} }
+        sig { returns(URI::Generic) }
+        attr_reader :url
+        sig { params(socket: T.anything, url: URI::Generic).returns(T.attached_class) }
+        def self.new(socket:, url:)
+        end
+
+        sig do
+          params(block: T.nilable(T.proc.params(event: ServerEvent).void)).returns(
+            T.any(OpenAI::Live::Connection, T::Enumerator[ServerEvent])
+          )
+        end
+        def each(&block)
+        end
+
+        sig { returns(T.nilable(ServerEvent)) }
+        def receive
+        end
+
+        sig { returns(T.nilable(String)) }
+        def receive_raw
+        end
+
+        sig { params(event: ClientEvent).void }
+        def send_event(event)
+        end
+
+        sig { params(data: String).void }
+        def send_raw(data)
+        end
+
+        sig { params(code: Integer, reason: String).void }
+        def close(code: 1000, reason: "")
+        end
+
+        sig { void }
+        def abort
+        end
+
+        sig { returns(T::Boolean) }
+        def closed?
+        end
+      end
+
+      class SidebandConnection
+        include Enumerable
+        ClientEvent = T.type_alias do
+          T.any(
+            OpenAI::Live::SessionUpdateEvent,
+            OpenAI::Live::InputAudioMuteEvent,
+            OpenAI::Live::InputAudioUnmuteEvent,
+            OpenAI::Live::InstructionsAppendEvent,
+            OpenAI::Live::ThinkingAppendEvent,
+            OpenAI::Live::CommentaryAppendEvent,
+            OpenAI::Live::ResponseItemCreateEvent,
+            OpenAI::Live::ResponseCreateEvent,
+            OpenAI::Live::SessionCloseEvent,
+            T::Hash[T.any(String, Symbol), T.anything]
+          )
+        end
+
+        Elem = type_member { {fixed: Connection::ServerEvent} }
+        sig { returns(URI::Generic) }
+        attr_reader :url
+        sig { params(socket: T.anything, url: URI::Generic).returns(T.attached_class) }
+        def self.new(socket:, url:)
+        end
+
+        sig do
+          params(block: T.nilable(T.proc.params(event: Connection::ServerEvent).void)).returns(
+            T.any(OpenAI::Live::SidebandConnection, T::Enumerator[Connection::ServerEvent])
+          )
+        end
+        def each(&block)
+        end
+
+        sig { returns(T.nilable(Connection::ServerEvent)) }
+        def receive
+        end
+
+        sig { returns(T.nilable(String)) }
+        def receive_raw
+        end
+
+        sig { params(event: ClientEvent).void }
+        def send_event(event)
+        end
+
+        sig { params(data: String).void }
+        def send_raw(data)
+        end
+
+        sig { params(code: Integer, reason: String).void }
+        def close(code: 1000, reason: "")
+        end
+
+        sig { void }
+        def abort
+        end
+
+        sig { returns(T::Boolean) }
+        def closed?
+        end
+      end
+
+      # Fork sessions use distinct input/output variants; expose that protocol
+      # directly so the primary Connection's shipped signatures stay precise.
+      class ForkConnection
+        include Enumerable
+        ServerEvent = T.type_alias { T.any(OpenAI::Live::ForkServerEvent::Variants, OpenAI::Live::UnknownServerEvent) }
+        ClientEvent = T.type_alias do
+          T.any(OpenAI::Live::ForkClientEvent::Variants, T::Hash[T.any(String, Symbol), T.anything])
+        end
+
+        Elem = type_member { {fixed: ServerEvent} }
+        sig { returns(URI::Generic) }
+        attr_reader :url
+        sig { params(socket: T.anything, url: URI::Generic).returns(T.attached_class) }
+        def self.new(socket:, url:)
+        end
+
+        sig do
+          params(block: T.nilable(T.proc.params(event: ServerEvent).void)).returns(
+            T.any(OpenAI::Live::ForkConnection, T::Enumerator[ServerEvent])
+          )
+        end
+        def each(&block)
+        end
+
+        sig { returns(T.nilable(ServerEvent)) }
+        def receive
+        end
+
+        sig { returns(T.nilable(String)) }
+        def receive_raw
+        end
+
+        sig { params(event: ClientEvent).void }
+        def send_event(event)
+        end
+
+        sig { params(data: String).void }
+        def send_raw(data)
+        end
+
+        sig { params(code: Integer, reason: String).void }
+        def close(code: 1000, reason: "")
+        end
+
+        sig { void }
+        def abort
+        end
+
+        sig { returns(T::Boolean) }
+        def closed?
+        end
+      end
+    end
+  end
+
+  module Resources
+    class Live
+      sig do
+        type_parameters(:T)
+          .params(
+            websocket_base_url: T.nilable(String),
+            request_options: T.nilable(OpenAI::RequestOptions::OrHash),
+            transport: T.untyped,
+            transport_options: T::Hash[Symbol, T.anything],
+            block: T.proc.params(connection: OpenAI::Live::Connection).returns(T.type_parameter(:T))
+          )
+          .returns(T.type_parameter(:T))
+      end
+      def connect(websocket_base_url: nil, request_options: nil, transport: nil, transport_options: {}, &block)
+      end
+
+      class Sideband
+        sig do
+          type_parameters(:T)
+            .params(
+              session_id: String,
+              graceful_close: T.nilable(T::Boolean),
+              websocket_base_url: T.nilable(String),
+              request_options: T.nilable(OpenAI::RequestOptions::OrHash),
+              transport: T.untyped,
+              transport_options: T::Hash[Symbol, T.anything],
+              block: T.proc.params(connection: OpenAI::Live::SidebandConnection).returns(T.type_parameter(:T))
+            )
+            .returns(T.type_parameter(:T))
+        end
+        def connect(
+          session_id,
+          graceful_close: nil,
+          websocket_base_url: nil,
+          request_options: nil,
+          transport: nil,
+          transport_options: {},
+          &block
+        )
+        end
+      end
+
+      class Forks
+        sig do
+          type_parameters(:T)
+            .params(
+              session_id: String,
+              websocket_base_url: T.nilable(String),
+              request_options: T.nilable(OpenAI::RequestOptions::OrHash),
+              transport: T.untyped,
+              transport_options: T::Hash[Symbol, T.anything],
+              block: T.proc.params(connection: OpenAI::Live::ForkConnection).returns(T.type_parameter(:T))
+            )
+            .returns(T.type_parameter(:T))
+        end
+        def connect(
+          session_id,
+          websocket_base_url: nil,
+          request_options: nil,
+          transport: nil,
+          transport_options: {},
+          &block
+        )
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/realtime/translation.rbi

@@ -0,0 +1,137 @@
+# typed: strong
+
+module OpenAI
+  class Client < OpenAI::Internal::Transport::BaseClient
+    # @api private
+    sig do
+      params(
+        model: String,
+        websocket_base_url: T.nilable(String),
+        options: T.nilable(OpenAI::RequestOptions::OrHash),
+        block: T
+          .proc
+          .params(
+            request: OpenAI::Internal::Transport::BaseClient::RequestInput,
+            mark_handshake_completed: T.proc.void
+          )
+          .returns(T.anything)
+      )
+        .returns(T.anything)
+    end
+    def with_translation_connection_request(model:, websocket_base_url: nil, options: nil, &block)
+    end
+  end
+
+  module Errors
+    class TranslationConnectionError < OpenAI::Errors::WebSocketConnectionError
+    end
+
+    class TranslationProtocolError < OpenAI::Errors::WebSocketProtocolError
+      sig { returns(T.attached_class) }
+      def self.new
+      end
+    end
+  end
+
+  module Models
+    module Realtime
+      class UnknownTranslationServerEvent < OpenAI::Realtime::UnknownServerEvent
+        sig { returns(String) }
+        def inspect
+        end
+
+        alias to_s inspect
+      end
+
+      class TranslationConnection
+        include Enumerable
+        ServerEvent = T.type_alias do
+          T.any(
+            OpenAI::Realtime::RealtimeTranslationServerEvent::Variants,
+            OpenAI::Realtime::UnknownTranslationServerEvent
+          )
+        end
+
+        ClientEvent = T.type_alias do
+          T.any(OpenAI::Realtime::RealtimeTranslationClientEvent::Variants, T::Hash[T.any(String, Symbol), T.anything])
+        end
+
+        Elem = type_member { {fixed: ServerEvent} }
+        sig { returns(URI::Generic) }
+        attr_reader :url
+        sig { params(socket: T.anything, url: URI::Generic).returns(T.attached_class) }
+        def self.new(socket:, url:)
+        end
+
+        sig do
+          params(block: T.nilable(T.proc.params(event: ServerEvent).void)).returns(
+            T.any(OpenAI::Realtime::TranslationConnection, T::Enumerator[ServerEvent])
+          )
+        end
+        def each(&block)
+        end
+
+        sig { returns(T.nilable(ServerEvent)) }
+        def receive
+        end
+
+        sig { returns(T.nilable(String)) }
+        def receive_raw
+        end
+
+        sig { params(event: ClientEvent).void }
+        def send_event(event)
+        end
+
+        sig do
+          params(timeout: Numeric, block: T.proc.params(event: ServerEvent).void)
+            .returns(OpenAI::Realtime::RealtimeTranslationSessionClosedEvent)
+        end
+        def finish(timeout:, &block)
+        end
+
+        sig { params(data: String).void }
+        def send_raw(data)
+        end
+
+        sig { params(code: Integer, reason: String).void }
+        def close(code: 1000, reason: "")
+        end
+
+        sig { void }
+        def abort
+        end
+
+        sig { returns(T::Boolean) }
+        def closed?
+        end
+      end
+    end
+  end
+
+  module Resources
+    class Realtime
+      sig do
+        type_parameters(:T)
+          .params(
+            model: String,
+            websocket_base_url: T.nilable(String),
+            request_options: T.nilable(OpenAI::RequestOptions::OrHash),
+            transport: T.untyped,
+            transport_options: T::Hash[Symbol, T.anything],
+            block: T.proc.params(connection: OpenAI::Realtime::TranslationConnection).returns(T.type_parameter(:T))
+          )
+          .returns(T.type_parameter(:T))
+      end
+      def connect_translation(
+        model:,
+        websocket_base_url: nil,
+        request_options: nil,
+        transport: nil,
+        transport_options: {},
+        &block
+      )
+      end
+    end
+  end
+end

data/rbi/openai/helpers/responses_websocket/incremental.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class IncrementalResponse
+        sig { returns(T.attached_class) }
+        def self.new
+        end
+
+        sig { returns(T.nilable(Symbol)) }
+        attr_reader :phase
+
+        sig { returns(T.nilable(T::Array[T.any(ResponseOutputItem::Variants, T::Hash[Symbol, T.untyped])])) }
+        def output
+        end
+
+        sig { returns(T.nilable(Connection::ServerEvent)) }
+        def terminal_event
+        end
+
+        sig { params(event: Connection::ServerEvent).void }
+        def add(event)
+        end
+
+        sig { void }
+        def reset
+        end
+      end
+    end
+  end
+end

data/rbi/openai/helpers/responses_websocket/transports/async_websocket.rbi

@@ -5,6 +5,30 @@ module OpenAI
     module Responses
       module Transports
         class AsyncWebSocket
+          # @api private
+          module PeekableFramer
+            # @api private
+            sig { returns(T::Boolean) }
+            def next_frame_compressed?
+            end
+          end
+
+          # @api private
+          class BoundedFramer
+            # @api private
+            sig { params(value: T::Boolean).returns(T::Boolean) }
+            def compression_negotiated=(value)
+            end
+          end
+
+          # @api private
+          module BoundedInflate
+            # @api private
+            sig { params(max_bytes: Integer, framer: BoundedFramer).void }
+            def bound_decoded_messages(max_bytes, framer)
+            end
+          end
+
           sig { void }
           def initialize
           end

data/rbi/openai/helpers/streaming/response_stream.rbi

@@ -96,6 +96,11 @@ module OpenAI
         def accumulate_event(event:, current_snapshot:)
         end
 
+        # @api private
+        sig { params(event: T.untyped, items: T::Array[T.untyped]).void }
+        def accumulate_output(event, items)
+        end
+
         private
 
         sig { params(value: String, delta: String).returns(String) }

data/rbi/openai/internal/type/converter.rbi

@@ -14,6 +14,7 @@ module OpenAI
         CoerceState = T.type_alias do
           {
             translate_names: T::Boolean,
+            request_only: T::Boolean,
             strictness: T::Boolean,
             exactness: {
               yes: Integer,
@@ -122,11 +123,11 @@ module OpenAI
 
           # @api private
           sig do
-            params(translate_names: T::Boolean).returns(
+            params(translate_names: T::Boolean, request_only: T::Boolean).returns(
               OpenAI::Internal::Type::Converter::CoerceState
             )
           end
-          def self.new_coerce_state(translate_names: true)
+          def self.new_coerce_state(translate_names: true, request_only: false)
           end
 
           # @api private

data/rbi/openai/models/audio/speech_create_params.rbi

@@ -249,6 +249,9 @@ module OpenAI
           VERSE = T.let(:verse, OpenAI::Audio::SpeechCreateParams::Voice::TaggedSymbol)
           MARIN = T.let(:marin, OpenAI::Audio::SpeechCreateParams::Voice::TaggedSymbol)
           CEDAR = T.let(:cedar, OpenAI::Audio::SpeechCreateParams::Voice::TaggedSymbol)
+          FABLE = T.let(:fable, OpenAI::Audio::SpeechCreateParams::Voice::TaggedSymbol)
+          ONYX = T.let(:onyx, OpenAI::Audio::SpeechCreateParams::Voice::TaggedSymbol)
+          NOVA = T.let(:nova, OpenAI::Audio::SpeechCreateParams::Voice::TaggedSymbol)
 
         end
 

data/rbi/openai/models/audio/transcription_create_response.rbi

@@ -14,7 +14,8 @@ module OpenAI
           T.any(
             OpenAI::Audio::Transcription,
             OpenAI::Audio::TranscriptionDiarized,
-            OpenAI::Audio::TranscriptionVerbose
+            OpenAI::Audio::TranscriptionVerbose,
+            StringIO
           )
         end
 

data/rbi/openai/models/audio/translation_create_response.rbi

@@ -11,7 +11,8 @@ module OpenAI
         Variants = T.type_alias do
           T.any(
             OpenAI::Audio::Translation,
-            OpenAI::Audio::TranslationVerbose
+            OpenAI::Audio::TranslationVerbose,
+            StringIO
           )
         end
 

data/rbi/openai/models/beta/agent.rbi

@@ -195,6 +195,7 @@ module OpenAI
           FLEX = T.let(:flex, OpenAI::Beta::Agent::ServiceTier::TaggedSymbol)
           PRIORITY = T.let(:priority, OpenAI::Beta::Agent::ServiceTier::TaggedSymbol)
           FAST = T.let(:fast, OpenAI::Beta::Agent::ServiceTier::TaggedSymbol)
+          ULTRAFAST = T.let(:ultrafast, OpenAI::Beta::Agent::ServiceTier::TaggedSymbol)
 
           sig { override.returns(T::Array[OpenAI::Beta::Agent::ServiceTier::TaggedSymbol]) }
           def self.values

data/rbi/openai/models/beta/agent_create_params.rbi

@@ -203,6 +203,9 @@ module OpenAI
           # Uses the fast service tier.
           FAST = T.let(:fast, OpenAI::Beta::AgentCreateParams::ServiceTier::TaggedSymbol)
 
+          # Uses the ultrafast service tier.
+          ULTRAFAST = T.let(:ultrafast, OpenAI::Beta::AgentCreateParams::ServiceTier::TaggedSymbol)
+
           sig { override.returns(T::Array[OpenAI::Beta::AgentCreateParams::ServiceTier::TaggedSymbol]) }
           def self.values
           end

data/rbi/openai/models/beta/agent_session.rbi

@@ -319,6 +319,7 @@ module OpenAI
             FLEX = T.let(:flex, OpenAI::Beta::AgentSession::Agent::ServiceTier::TaggedSymbol)
             PRIORITY = T.let(:priority, OpenAI::Beta::AgentSession::Agent::ServiceTier::TaggedSymbol)
             FAST = T.let(:fast, OpenAI::Beta::AgentSession::Agent::ServiceTier::TaggedSymbol)
+            ULTRAFAST = T.let(:ultrafast, OpenAI::Beta::AgentSession::Agent::ServiceTier::TaggedSymbol)
 
             sig { override.returns(T::Array[OpenAI::Beta::AgentSession::Agent::ServiceTier::TaggedSymbol]) }
             def self.values

data/rbi/openai/models/beta/agent_update_params.rbi

@@ -214,6 +214,9 @@ module OpenAI
           # Uses the fast service tier.
           FAST = T.let(:fast, OpenAI::Beta::AgentUpdateParams::ServiceTier::TaggedSymbol)
 
+          # Uses the ultrafast service tier.
+          ULTRAFAST = T.let(:ultrafast, OpenAI::Beta::AgentUpdateParams::ServiceTier::TaggedSymbol)
+
           sig { override.returns(T::Array[OpenAI::Beta::AgentUpdateParams::ServiceTier::TaggedSymbol]) }
           def self.values
           end

data/rbi/openai/models/beta/agents/environments/template_create_params.rbi

@@ -50,7 +50,7 @@ module OpenAI
             attr_accessor :name
 
             # Network access policy for the environment. Defaults to disabled for GA requests
-            # and enabled for alpha/beta requests.
+            # and enabled for beta requests.
             sig { returns(T.nilable(OpenAI::Beta::Agents::Environments::TemplateCreateParams::Network)) }
             attr_reader :network
 
@@ -145,7 +145,7 @@ module OpenAI
               name: nil,
 
               # Network access policy for the environment. Defaults to disabled for GA requests
-              # and enabled for alpha/beta requests.
+              # and enabled for beta requests.
               network: nil,
 
               # Packages to install in the environment. Defaults to empty package lists.
@@ -212,7 +212,7 @@ module OpenAI
               attr_accessor :allowed_domains
 
               # Network access policy for the environment. Defaults to disabled for GA requests
-              # and enabled for alpha/beta requests.
+              # and enabled for beta requests.
               sig do
                 params(
 

data/rbi/openai/models/beta/agents/environments/template_update_params.rbi

@@ -52,8 +52,8 @@ module OpenAI
             attr_accessor :name
 
             # Network access available after setup completes. Omit to preserve the current
-            # policy, or pass `null` to reset to disabled for GA requests or enabled for
-            # alpha/beta requests.
+            # policy, or pass `null` to reset to disabled for GA requests or enabled for beta
+            # requests.
             sig { returns(T.nilable(OpenAI::Beta::Agents::Environments::TemplateUpdateParams::Network)) }
             attr_reader :network
 
@@ -150,8 +150,8 @@ module OpenAI
               name: nil,
 
               # Network access available after setup completes. Omit to preserve the current
-              # policy, or pass `null` to reset to disabled for GA requests or enabled for
-              # alpha/beta requests.
+              # policy, or pass `null` to reset to disabled for GA requests or enabled for beta
+              # requests.
               network: nil,
 
               # Packages installed before the runtime network policy applies.
@@ -218,8 +218,8 @@ module OpenAI
               attr_accessor :allowed_domains
 
               # Network access available after setup completes. Omit to preserve the current
-              # policy, or pass `null` to reset to disabled for GA requests or enabled for
-              # alpha/beta requests.
+              # policy, or pass `null` to reset to disabled for GA requests or enabled for beta
+              # requests.
               sig do
                 params(
 

data/rbi/openai/models/beta/agents/session_create_params.rbi

@@ -309,6 +309,9 @@ module OpenAI
               # Uses the fast service tier.
               FAST = T.let(:fast, OpenAI::Beta::Agents::SessionCreateParams::Agent::ServiceTier::TaggedSymbol)
 
+              # Uses the ultrafast service tier.
+              ULTRAFAST = T.let(:ultrafast, OpenAI::Beta::Agents::SessionCreateParams::Agent::ServiceTier::TaggedSymbol)
+
               sig {
                 override.returns(T::Array[OpenAI::Beta::Agents::SessionCreateParams::Agent::ServiceTier::TaggedSymbol])
               }

data/rbi/openai/models/beta/agents/session_update_params.rbi

@@ -234,6 +234,9 @@ module OpenAI
               # Uses the fast service tier.
               FAST = T.let(:fast, OpenAI::Beta::Agents::SessionUpdateParams::Agent::ServiceTier::TaggedSymbol)
 
+              # Uses the ultrafast service tier.
+              ULTRAFAST = T.let(:ultrafast, OpenAI::Beta::Agents::SessionUpdateParams::Agent::ServiceTier::TaggedSymbol)
+
               sig {
                 override.returns(T::Array[OpenAI::Beta::Agents::SessionUpdateParams::Agent::ServiceTier::TaggedSymbol])
               }