openai 0.106.0 → 0.108.0

data/rbi/openai/models/audio/voice_consent_deleted.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Audio
+
+      class VoiceConsentDeleted < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Audio::VoiceConsentDeleted,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # The consent recording identifier.
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T::Boolean) }
+        attr_accessor :deleted
+
+        sig { returns(Symbol) }
+        attr_accessor :object
+
+        sig do
+          params(
+
+            id: String,
+
+            deleted: T::Boolean,
+
+            object: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # The consent recording identifier.
+          id:,
+
+          deleted:,
+
+          object: :"audio.voice_consent"
+        )
+        end
+
+        sig do
+          override.returns(
+            {id: String, deleted: T::Boolean, object: Symbol}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/audio/voice_consent_list_params.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Audio
+
+      class VoiceConsentListParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Audio::VoiceConsentListParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # A cursor for use in pagination. `after` is an object ID that defines your place
+        # in the list. For instance, if you make a list request and receive 100 objects,
+        # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+        # fetch the next page of the list.
+        sig { returns(T.nilable(String)) }
+        attr_reader :after
+
+        sig { params(after: String).void }
+        attr_writer :after
+
+        # A limit on the number of objects to be returned. Limit can range between 1 and
+        # 100, and the default is 20.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        sig do
+          params(
+
+            after: String,
+
+            limit: Integer,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # A cursor for use in pagination. `after` is an object ID that defines your place
+          # in the list. For instance, if you make a list request and receive 100 objects,
+          # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+          # fetch the next page of the list.
+          after: nil,
+
+          # A limit on the number of objects to be returned. Limit can range between 1 and
+          # 100, and the default is 20.
+          limit: nil,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {after: String, limit: Integer, request_options: OpenAI::RequestOptions}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/audio/voice_consent_retrieve_params.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Audio
+
+      class VoiceConsentRetrieveParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Audio::VoiceConsentRetrieveParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(String) }
+        attr_accessor :consent_id
+
+        sig do
+          params(
+
+            consent_id: String,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          consent_id:,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {consent_id: String, request_options: OpenAI::RequestOptions}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/audio/voice_consent_update_params.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Audio
+
+      class VoiceConsentUpdateParams < OpenAI::Internal::Type::BaseModel
+
+        extend OpenAI::Internal::Type::RequestParameters::Converter
+        include OpenAI::Internal::Type::RequestParameters
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Audio::VoiceConsentUpdateParams,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        sig { returns(String) }
+        attr_accessor :consent_id
+
+        # The updated label for this consent recording.
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig do
+          params(
+
+            consent_id: String,
+
+            name: String,
+
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          consent_id:,
+
+          # The updated label for this consent recording.
+          name:,
+
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {consent_id: String, name: String, request_options: OpenAI::RequestOptions}
+          )
+        end
+        def to_hash
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/beta/beta_response_input_item.rbi

@@ -5130,6 +5130,10 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The unique ID of this compaction trigger.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :id
+
           # The agent that produced this item.
           sig { returns(T.nilable(OpenAI::Beta::BetaResponseInputItem::CompactionTrigger::Agent)) }
           attr_reader :agent
@@ -5141,6 +5145,8 @@ module OpenAI
           sig do
             params(
 
+              id: T.nilable(String),
+
               agent: T.nilable(OpenAI::Beta::BetaResponseInputItem::CompactionTrigger::Agent::OrHash),
 
               type: Symbol
@@ -5149,6 +5155,9 @@ module OpenAI
           end
           def self.new(
 
+            # The unique ID of this compaction trigger.
+            id: nil,
+
             # The agent that produced this item.
             agent: nil,
 
@@ -5160,7 +5169,11 @@ module OpenAI
 
           sig do
             override.returns(
-              {type: Symbol, agent: T.nilable(OpenAI::Beta::BetaResponseInputItem::CompactionTrigger::Agent)}
+              {
+                type: Symbol,
+                id: T.nilable(String),
+                agent: T.nilable(OpenAI::Beta::BetaResponseInputItem::CompactionTrigger::Agent)
+              }
             )
           end
           def to_hash

data/rbi/openai/models/response_format_json_schema.rbi

@@ -2,24 +2,25 @@
 
 module OpenAI
   module Models
+
     class ResponseFormatJSONSchema < OpenAI::Internal::Type::BaseModel
+
       OrHash = T.type_alias do
-        T.any(OpenAI::ResponseFormatJSONSchema, OpenAI::Internal::AnyHash)
+        T.any(
+          OpenAI::ResponseFormatJSONSchema,
+          OpenAI::Internal::AnyHash
+        )
       end
 
       # Structured Outputs configuration options, including a JSON Schema.
-      sig do
+      sig {
         returns(
-          T.any(
-            OpenAI::ResponseFormatJSONSchema::JSONSchema::OrHash,
-            OpenAI::StructuredOutput::JsonSchemaConverter
-          )
+          T.any(OpenAI::ResponseFormatJSONSchema::JSONSchema::OrHash, OpenAI::StructuredOutput::JsonSchemaConverter)
         )
-      end
-
+      }
       attr_reader :json_schema
 
-      sig do
+      sig {
         params(
           json_schema: T.any(
             OpenAI::ResponseFormatJSONSchema::JSONSchema::OrHash,
@@ -27,8 +28,7 @@ module OpenAI
           )
         )
           .void
-      end
-
+      }
       attr_writer :json_schema
 
       # The type of response format being defined. Always `json_schema`.
@@ -40,10 +40,12 @@ module OpenAI
       # [Structured Outputs](https://developers.openai.com/api/docs/guides/structured-outputs).
       sig do
         params(
+
           json_schema: T.any(
             OpenAI::ResponseFormatJSONSchema::JSONSchema::OrHash,
             OpenAI::StructuredOutput::JsonSchemaConverter
           ),
+
           type: Symbol
         )
           .returns(T.attached_class)

data/rbi/openai/models/responses/response_input_item.rbi

@@ -3433,16 +3433,25 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The unique ID of this compaction trigger.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :id
+
           # Compacts the current context. Must be the final input item.
           sig do
             params(
 
+              id: T.nilable(String),
+
               type: Symbol
             )
               .returns(T.attached_class)
           end
           def self.new(
 
+            # The unique ID of this compaction trigger.
+            id: nil,
+
             # The type of the item. Always `compaction_trigger`.
 
             type: :compaction_trigger
@@ -3451,7 +3460,7 @@ module OpenAI
 
           sig do
             override.returns(
-              {type: Symbol}
+              {type: Symbol, id: T.nilable(String)}
             )
           end
           def to_hash

data/rbi/openai/resources/audio/voice_consents.rbi

@@ -0,0 +1,108 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+
+    class Audio
+
+      # Turn audio into text or text into audio.
+      class VoiceConsents
+
+        # Upload a voice consent recording.
+        sig {
+          params(
+            language: String,
+            name: String,
+            recording: OpenAI::Internal::FileInput,
+            request_options: OpenAI::RequestOptions::OrHash
+          )
+            .returns(OpenAI::Audio::VoiceConsent)
+        }
+        def create(
+          # The BCP 47 language tag for the consent phrase (for example, `en-US`).
+          language:,
+          # The label to use for this consent recording.
+          name:,
+          # The consent audio recording file. Maximum size is 10 MiB.
+          #
+          # Supported MIME types: `audio/mpeg`, `audio/wav`, `audio/x-wav`, `audio/ogg`,
+          # `audio/aac`, `audio/flac`, `audio/webm`, `audio/mp4`.
+          #
+          # `String`, `StringIO`, and pathless `IO` inputs are sent with generic upload
+          # metadata. Use `OpenAI::FilePart` when you need to override the filename or
+          # content type.
+          recording:,
+          request_options: {}
+        )
+        end
+
+        # Retrieves a voice consent recording.
+        sig {
+          params(consent_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
+            OpenAI::Audio::VoiceConsent
+          )
+        }
+        def retrieve(
+          # The ID of the consent recording to retrieve.
+          consent_id,
+          request_options: {}
+        )
+        end
+
+        # Updates a voice consent recording (metadata only).
+        sig {
+          params(consent_id: String, name: String, request_options: OpenAI::RequestOptions::OrHash).returns(
+            OpenAI::Audio::VoiceConsent
+          )
+        }
+        def update(
+          # The ID of the consent recording to update.
+          consent_id,
+          # The updated label for this consent recording.
+          name:,
+          request_options: {}
+        )
+        end
+
+        # Returns a list of voice consent recordings.
+        sig {
+          params(after: String, limit: Integer, request_options: OpenAI::RequestOptions::OrHash).returns(
+            OpenAI::Internal::CursorPage[OpenAI::Audio::VoiceConsent]
+          )
+        }
+        def list(
+          # A cursor for use in pagination. `after` is an object ID that defines your place
+          # in the list. For instance, if you make a list request and receive 100 objects,
+          # ending with obj_foo, your subsequent call can include after=obj_foo in order to
+          # fetch the next page of the list.
+          after: nil,
+          # A limit on the number of objects to be returned. Limit can range between 1 and
+          # 100, and the default is 20.
+          limit: nil,
+          request_options: {}
+        )
+        end
+
+        # Deletes a voice consent recording.
+        sig {
+          params(consent_id: String, request_options: OpenAI::RequestOptions::OrHash).returns(
+            OpenAI::Audio::VoiceConsentDeleted
+          )
+        }
+        def delete(
+          # The ID of the consent recording to delete.
+          consent_id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: OpenAI::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+
+    end
+
+  end
+end

data/rbi/openai/resources/audio.rbi

@@ -21,6 +21,10 @@ module OpenAI
       sig { returns(OpenAI::Resources::Audio::Voices) }
       attr_reader :voices
 
+      # Turn audio into text or text into audio.
+      sig { returns(OpenAI::Resources::Audio::VoiceConsents) }
+      attr_reader :voice_consents
+
       # @api private
       sig { params(client: OpenAI::Client).returns(T.attached_class) }
       def self.new(client:)

data/realtime.md

@@ -468,6 +468,8 @@ Malformed known events raise `OpenAI::Errors::RealtimeProtocolError`. A valid
 JSON object with a newer, unknown event discriminator is returned as
 `OpenAI::Realtime::UnknownServerEvent`, preserving its deeply frozen payload so
 an additive service event does not terminate an otherwise healthy session.
+Its `inspect` and `to_s` output omits remote values. Access `type`, `data`, or
+`to_h` explicitly when those values are needed.
 
 ```ruby
 connection.each do |event|
@@ -495,6 +497,11 @@ Connection and protocol failures use distinct error classes:
 - `OpenAI::Errors::RealtimeProtocolError` exposes the invalid raw `data` and
   original `cause`.
 
+For these connection and protocol errors, default rendering, including
+`full_message`, suppresses native cause chains, including exceptions active when
+an SDK state check fails. Explicit `data` and `cause` access can expose remote
+payloads or credentials; sanitize these values before logging or sharing them.
+
 The configured request timeout bounds WebSocket negotiation. It does not become
 an idle-session deadline after the connection is established.
 
@@ -595,6 +602,18 @@ The examples in this guide cover local function calling, image input, and MCP
 approval through the generic Realtime connection API, alongside generated
 WebRTC/SDP call creation and sideband control of existing WebRTC and SIP calls.
 Continuous microphone capture, concurrent live captioning, full-duplex
-conversation, SIP call-ownership orchestration, and translation connections
-remain out of scope. Existing generated HTTP resources remain
-generated-code-owned.
+conversation, and SIP call-ownership orchestration are outside this guide's
+scope.
+
+## Translation connections
+
+The SDK also supports the separate Translation WebSocket protocol through
+`client.realtime.connect_translation(model: ...) { |connection| ... }`.
+It uses Translation event types rather than the Realtime events shown above.
+See the [Translation connection helper](lib/openai/helpers/realtime/translation.rb)
+and [server event types](lib/openai/models/realtime/realtime_translation_server_event.rb).
+
+After sending input, call `connection.finish(timeout: ...)` with a block to
+consume the remaining events through `session.closed`. Finish calls must be
+sequential, with no competing reader. Keep the connection inside its opening
+block so the SDK can clean it up when the block exits.

data/sig/openai/client.rbs

@@ -75,7 +75,7 @@ module OpenAI
     attr_reader videos: OpenAI::Resources::Videos
 
     private def auth_headers: (
-      security: { :bearer_auth? => bool, :admin_api_key_auth? => bool }
+      security: { ?bearer_auth: bool, ?admin_api_key_auth: bool }
     ) -> ::Hash[String, String]
 
     private def bearer_auth: -> ::Hash[String, String]

data/sig/openai/helpers/chat/tool_runner.rbs

@@ -0,0 +1,48 @@
+module OpenAI
+  module Helpers
+    module Chat
+      class ToolRunner
+        type handler = ^(Hash[String, untyped]) -> untyped
+
+        class Error < StandardError
+        end
+
+        class MaxRoundsError < Error
+        end
+
+        # @api private
+        def initialize: (
+          completions: OpenAI::Resources::Chat::Completions,
+          params: Hash[Symbol, untyped],
+          tool_handlers: Hash[String, handler],
+          max_rounds: Integer
+        ) -> void
+
+        # @api private
+        def run: -> OpenAI::Chat::ChatCompletion
+      end
+    end
+  end
+
+  module Resources
+    class Chat
+      class Completions
+        # @api private
+        def create_for_tool_runner: (
+          Hash[Symbol, untyped] params
+        ) -> OpenAI::Chat::ChatCompletion
+
+        def run_tools: (
+          model: String | Symbol,
+          messages: Array[untyped],
+          tools: Array[Class
+          | OpenAI::Chat::ChatCompletionFunctionTool
+          | Hash[Symbol, untyped]],
+          tool_handlers: Hash[String, OpenAI::Helpers::Chat::ToolRunner::handler],
+          ?max_rounds: Integer,
+          **untyped
+        ) -> OpenAI::Chat::ChatCompletion
+      end
+    end
+  end
+end

data/sig/openai/helpers/realtime/translation.rbs

@@ -31,8 +31,6 @@ module OpenAI
         | ::Hash[Symbol | String, untyped]
 
       class UnknownTranslationServerEvent < OpenAI::Realtime::UnknownServerEvent
-        def inspect: -> String
-        alias to_s inspect
       end
       class TranslationConnection
         include Enumerable[OpenAI::Models::Realtime::translation_connection_server_event]

data/sig/openai/helpers/realtime/unknown_server_event.rbs

@@ -8,6 +8,8 @@ module OpenAI
         # @api private
         def initialize: (data: ::Hash[Symbol, untyped]) -> void
         def to_h: -> ::Hash[Symbol, untyped]
+        def inspect: -> String
+        alias to_s inspect
       end
     end
   end

data/sig/openai/helpers/websocket.rbs

@@ -23,17 +23,34 @@ module OpenAI
         ?transport: untyped,
         ?transport_options: Hash[untyped, untyped]
       ) {
-        (TypedConnection) -> untyped
+        (TypedConnection[untyped, untyped]) -> untyped
       } -> untyped
     end
 
-    class TypedConnection
-      include Enumerable[untyped]
+    module TypedResource[WebSocketClientEvent, WebSocketServerEvent]
+      include Resource
+
+      def connect: (
+        *untyped path_arguments,
+        ?query: Hash[untyped, untyped],
+        ?websocket_base_url: String?,
+        ?request_options: untyped,
+        ?transport: untyped,
+        ?transport_options: Hash[untyped, untyped]
+      ) {
+        (TypedConnection[WebSocketClientEvent, WebSocketServerEvent]) -> untyped
+      } -> untyped
+    end
+
+    class TypedConnection[in ClientEvent, out Elem]
+      include Enumerable[Elem]
 
       attr_reader url: URI::Generic
-      def receive: -> untyped
-      def send_event: (untyped event) -> void
-      def each: -> Enumerator[untyped, self] | { (untyped) -> void } -> self
+      def receive: -> Elem?
+      def send_event: (
+        ClientEvent | Hash[String | Symbol, untyped] event
+      ) -> void
+      def each: -> Enumerator[Elem, self] | { (Elem) -> void } -> self
       def close: (?code: Integer, ?reason: String) -> void
       def closed?: -> bool
     end