openai 0.95.0 → 0.97.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

@@ -106,7 +106,8 @@ module OpenAI
                 OpenAI::Beta::PersistedAgentTool::ToolSearch::OrHash,
                 OpenAI::Beta::PersistedAgentTool::ProgrammaticToolCalling::OrHash,
                 OpenAI::Beta::PersistedAgentTool::Mcp::OrHash,
-                OpenAI::Beta::PersistedAgentTool::WebSearch::OrHash
+                OpenAI::Beta::PersistedAgentTool::WebSearch::OrHash,
+                OpenAI::Beta::PersistedAgentTool::ComputerUse::OrHash
               )
             ],
 
@@ -195,6 +196,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_browser_authentication_cancel_param.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Beta
+
+      class AgentBrowserAuthenticationCancelParam < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Beta::AgentBrowserAuthenticationCancelParam,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(Symbol) }
+        attr_accessor :action
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+
+            action: Symbol,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          action: :cancel,
+
+          type: :browser_authentication
+        )
+        end
+
+        sig do
+          override.returns(
+            {action: Symbol, type: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end