openai 0.77.1 → 0.79.0

data/rbi/openai/internal/logging.rbi

@@ -0,0 +1,192 @@
+# typed: strong
+
+module OpenAI
+  module Internal
+    module Logging
+      LOG_LEVELS = T.let(T.unsafe(nil), T::Hash[Symbol, Integer])
+      REDACTED_HEADERS = T.let(T.unsafe(nil), T::Array[String])
+      MAX_BODY_BYTES = T.let(T.unsafe(nil), Integer)
+      MAX_ARRAY_ITEMS = T.let(T.unsafe(nil), Integer)
+      OPAQUE_STRING_BYTES = T.let(T.unsafe(nil), Integer)
+      SENSITIVE_BODY_KEY = T.let(T.unsafe(nil), Regexp)
+      SENSITIVE_QUERY_KEY = T.let(T.unsafe(nil), Regexp)
+      URL_HEADER_KEY = T.let(T.unsafe(nil), Regexp)
+
+      class Context
+        sig do
+          params(
+            logger: T.untyped,
+            log_level: Symbol,
+            on_retry: T.nilable(T.proc.params(event: OpenAI::RetryEvent).void),
+            method: Symbol,
+            url: URI::Generic
+          ).returns(T.attached_class)
+        end
+        def self.new(logger:, log_level:, on_retry:, method:, url:)
+        end
+
+        sig do
+          params(
+            request: OpenAI::HTTPClient::Request,
+            redirect_count: Integer
+          ).void
+        end
+        def request_started(request, redirect_count:)
+        end
+
+        sig do
+          params(response: OpenAI::HTTPClient::Response).returns(
+            OpenAI::HTTPClient::Response
+          )
+        end
+        def response_received(response)
+        end
+
+        sig { params(error: OpenAI::Errors::APIConnectionError).void }
+        def attempt_failed(error)
+        end
+
+        sig do
+          params(
+            cause: T.any(Integer, OpenAI::Errors::APIConnectionError),
+            delay: Float,
+            response: T.nilable(OpenAI::ResponseMetadata),
+            retry_count: Integer,
+            max_retries: Integer
+          ).void
+        end
+        def retry_scheduled(
+          cause,
+          delay:,
+          response:,
+          retry_count:,
+          max_retries:
+        )
+        end
+
+        sig { params(response: OpenAI::HTTPClient::Response).void }
+        def completed(response)
+        end
+
+        sig do
+          params(
+            stream: T.untyped,
+            response: OpenAI::HTTPClient::Response
+          ).returns(T.untyped)
+        end
+        def observe_stream(stream, response:)
+        end
+
+        sig { params(error: StandardError).void }
+        def request_failed(error)
+        end
+
+        sig do
+          params(
+            body: String,
+            headers: T::Hash[String, String],
+            complete: T::Boolean,
+            total_bytes: Integer,
+            attempt: Integer
+          ).void
+        end
+        def response_body(body, headers:, complete:, total_bytes:, attempt:)
+        end
+      end
+
+      class ObservedBody
+        include Enumerable
+
+        Elem = type_member { { fixed: String } }
+
+        sig do
+          params(
+            body: T::Enumerable[String],
+            headers: T::Hash[String, String],
+            context: OpenAI::Internal::Logging::Context,
+            attempt: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(body:, headers:, context:, attempt:)
+        end
+
+        sig { params(blk: T.untyped).returns(T.untyped) }
+        def each(&blk)
+        end
+
+        sig { void }
+        def close
+        end
+      end
+
+      class << self
+        sig { params(value: T.any(Symbol, String)).returns(Symbol) }
+        def normalize_level(value)
+        end
+
+        sig { params(logger: T.untyped).void }
+        def validate_logger!(logger)
+        end
+
+        sig { returns(Logger) }
+        def default_logger
+        end
+
+        sig do
+          params(configured_level: Symbol, event_level: Symbol).returns(
+            T::Boolean
+          )
+        end
+        def enabled?(configured_level, event_level)
+        end
+
+        sig { params(url: URI::Generic).returns(String) }
+        def safe_path(url)
+        end
+
+        sig { params(url: URI::Generic).returns(String) }
+        def safe_url(url)
+        end
+
+        sig { params(value: T.untyped).returns(String) }
+        def safe_field(value)
+        end
+
+        sig { params(name: T.any(String, Symbol)).returns(T::Boolean) }
+        def sensitive_header?(name)
+        end
+
+        sig { params(name: T.any(String, Symbol)).returns(T::Boolean) }
+        def credential_header?(name)
+        end
+
+        sig { params(headers: T::Hash[String, String]).returns(String) }
+        def format_headers(headers)
+        end
+
+        sig do
+          params(body: T.untyped, headers: T::Hash[String, String]).returns(
+            String
+          )
+        end
+        def format_body(body, headers:)
+        end
+
+        sig { params(headers: T::Hash[String, String]).returns(T::Boolean) }
+        def capture_response_body?(headers)
+        end
+
+        sig do
+          params(
+            body: String,
+            headers: T::Hash[String, String],
+            complete: T::Boolean,
+            total_bytes: Integer
+          ).returns(String)
+        end
+        def format_observed_body(body, headers:, complete:, total_bytes:)
+        end
+      end
+    end
+  end
+end

data/rbi/openai/internal/provider.rbi

@@ -23,6 +23,9 @@ module OpenAI
           )
         end
         attr_accessor :prepare_request
+
+        sig { returns(T::Array[String]) }
+        attr_accessor :authentication_headers
       end
 
       class << self

data/rbi/openai/internal/read_io_adapter.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module OpenAI
+  module Internal
+    module Util
+      # @api private
+      #
+      # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+      class ReadIOAdapter
+        # @api private
+        sig { returns(T.nilable(T::Boolean)) }
+        def close?
+        end
+
+        # @api private
+        sig { void }
+        def close
+        end
+
+        # @api private
+        sig { params(max_len: T.nilable(Integer)).returns(T.nilable(String)) }
+        private def read_enum(max_len)
+        end
+
+        # @api private
+        sig { params(max_len: Integer).returns(String) }
+        private def read_buffer(max_len)
+        end
+
+        # @api private
+        sig do
+          params(
+            max_len: T.nilable(Integer),
+            out_string: T.nilable(String)
+          ).returns(T.nilable(String))
+        end
+        def read(max_len = nil, out_string = nil)
+        end
+
+        # @api private
+        sig do
+          params(
+            src: T.any(String, Pathname, StringIO, T::Enumerable[String]),
+            blk: T.proc.params(arg0: String).void
+          ).returns(T.attached_class)
+        end
+        def self.new(src, &blk)
+        end
+      end
+    end
+  end
+end

data/rbi/openai/internal/transport/base_client.rbi

@@ -75,7 +75,7 @@ module OpenAI
               headers: T::Hash[String, String],
               body: T.anything,
               max_retries: Integer,
-              timeout: Float
+              timeout: T.nilable(Float)
             }
           end
 
@@ -103,6 +103,11 @@ module OpenAI
           def should_retry?(status, headers:)
           end
 
+          # @api private
+          sig { params(body: T.untyped).returns(T::Boolean) }
+          def request_body_replayable?(body)
+          end
+
           # @api private
           sig do
             params(
@@ -128,7 +133,7 @@ module OpenAI
         sig { returns(URI::Generic) }
         attr_reader :base_url
 
-        sig { returns(Float) }
+        sig { returns(T.nilable(Float)) }
         attr_reader :timeout
 
         sig { returns(Integer) }
@@ -146,15 +151,24 @@ module OpenAI
         sig { returns(T.nilable(String)) }
         attr_reader :idempotency_header
 
+        sig { returns(T.untyped) }
+        attr_reader :logger
+
+        sig { returns(Symbol) }
+        attr_reader :log_level
+
+        sig { returns(T.nilable(T.proc.params(event: OpenAI::RetryEvent).void)) }
+        attr_reader :on_retry
+
         # @api private
-        sig { returns(OpenAI::Internal::Transport::PooledNetRequester) }
+        sig { returns(T.untyped) }
         attr_reader :requester
 
         # @api private
         sig do
           params(
             base_url: String,
-            timeout: Float,
+            timeout: T.nilable(Float),
             max_retries: Integer,
             initial_retry_delay: Float,
             max_retry_delay: Float,
@@ -169,7 +183,11 @@ module OpenAI
                   )
                 )
               ],
-            idempotency_header: T.nilable(String)
+            idempotency_header: T.nilable(String),
+            http_client: T.untyped,
+            logger: T.untyped,
+            log_level: T.nilable(T.any(Symbol, String)),
+            on_retry: T.nilable(T.proc.params(event: OpenAI::RetryEvent).void)
           ).returns(T.attached_class)
         end
         def self.new(
@@ -179,7 +197,11 @@ module OpenAI
           initial_retry_delay: 0.0,
           max_retry_delay: 0.0,
           headers: {},
-          idempotency_header: nil
+          idempotency_header: nil,
+          http_client: nil,
+          logger: nil,
+          log_level: nil,
+          on_retry: nil
         )
         end
 
@@ -223,6 +245,15 @@ module OpenAI
         private def build_request(req, opts)
         end
 
+        # @api private
+        sig do
+          params(
+            request: OpenAI::Internal::Transport::BaseClient::RequestInput
+          ).returns(T::Boolean)
+        end
+        private def request_replayable?(request)
+        end
+
         # @api private
         sig do
           params(
@@ -239,7 +270,7 @@ module OpenAI
             url: URI::Generic,
             status: Integer,
             headers: T::Hash[String, String],
-            response: Net::HTTPResponse,
+            response: OpenAI::HTTPClient::Response,
             stream: T::Enumerable[String]
           ).returns(T.noreturn)
         end
@@ -258,14 +289,16 @@ module OpenAI
             request: OpenAI::Internal::Transport::BaseClient::RequestInput,
             redirect_count: Integer,
             retry_count: Integer,
-            send_retry_header: T::Boolean
-          ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
+            send_retry_header: T::Boolean,
+            context_provider: T.proc.returns(OpenAI::Internal::Logging::Context)
+          ).returns(OpenAI::HTTPClient::Response)
         end
         def send_request(
           request,
           redirect_count:,
           retry_count:,
-          send_retry_header:
+          send_retry_header:,
+          &context_provider
         )
         end
 
@@ -344,6 +377,43 @@ module OpenAI
         )
         end
 
+        # @api private
+        sig do
+          params(
+            req: OpenAI::Internal::Transport::BaseClient::RequestComponents
+          ).returns(
+            [
+              URI::Generic,
+              OpenAI::HTTPClient::Response,
+              OpenAI::Internal::Logging::Context
+            ]
+          )
+        end
+        private def perform_request(req)
+        end
+
+        # @api private
+        sig do
+          params(
+            log_context: OpenAI::Internal::Logging::Context,
+            response: OpenAI::HTTPClient::Response,
+            blk: T.proc.returns(T.anything)
+          ).returns(T.anything)
+        end
+        private def finish_request(log_context, response, &blk)
+        end
+
+        # @api private
+        sig do
+          params(
+            req: OpenAI::Internal::Transport::BaseClient::RequestComponents,
+            url: URI::Generic,
+            response: OpenAI::HTTPClient::Response
+          ).returns(T.anything)
+        end
+        private def parse_response(req, url:, response:)
+        end
+
         # @api private
         sig { returns(String) }
         def inspect

data/rbi/openai/internal/type/base_model.rbi

@@ -29,7 +29,7 @@ module OpenAI
           # Assumes superclass fields are totally defined before fields are accessed /
           # defined on subclasses.
           sig { params(child: OpenAI::Internal::Type::BaseModel).void }
-          def inherited(child)
+          def inherited(child) # rubocop:disable Lint/MissingSuper -- RBI declarations cannot contain executable bodies.
           end
 
           # @api private
@@ -161,6 +161,24 @@ module OpenAI
         def hash
         end
 
+        # The ID of the API request, returned via the `x-request-id` response
+        # header. This is only populated on top-level response objects returned
+        # by the client.
+        sig { returns(T.nilable(String)) }
+        def _request_id
+        end
+
+        # Metadata from the HTTP response that produced this model. This is
+        # only populated on top-level response objects returned by the client.
+        sig { returns(T.nilable(OpenAI::ResponseMetadata)) }
+        def last_response
+        end
+
+        # @api private
+        sig { params(response: OpenAI::ResponseMetadata).returns(T.self_type) }
+        def _set_last_response(response)
+        end
+
         class << self
           # @api private
           sig do
@@ -265,6 +283,11 @@ module OpenAI
         def to_yaml(*a)
         end
 
+        # @api private
+        sig { params(coder: T.untyped).void }
+        def encode_with(coder)
+        end
+
         # Create a new instance of a model.
         sig do
           params(

data/rbi/openai/internal/type/base_page.rbi

@@ -9,6 +9,17 @@ module OpenAI
       module BasePage
         Elem = type_member(:out)
 
+        # The ID of the API request, returned via the `x-request-id` response
+        # header. This is only populated on top-level response objects returned
+        # by the client.
+        sig { returns(T.nilable(String)) }
+        def _request_id
+        end
+
+        sig { returns(OpenAI::ResponseMetadata) }
+        def last_response
+        end
+
         sig { overridable.returns(T::Boolean) }
         def next_page?
         end
@@ -30,11 +41,11 @@ module OpenAI
           params(
             client: OpenAI::Internal::Transport::BaseClient,
             req: OpenAI::Internal::Transport::BaseClient::RequestComponents,
-            headers: T::Hash[String, String],
+            response_metadata: OpenAI::ResponseMetadata,
             page_data: T.anything
           ).void
         end
-        def initialize(client:, req:, headers:, page_data:)
+        def initialize(client:, req:, response_metadata:, page_data:)
         end
       end
     end

data/rbi/openai/internal/type/base_stream.rbi

@@ -18,10 +18,23 @@ module OpenAI
         sig { returns(T::Hash[String, String]) }
         attr_reader :headers
 
+        sig { returns(OpenAI::ResponseMetadata) }
+        attr_reader :last_response
+
         sig { void }
         def close
         end
 
+        # @api private
+        sig do
+          params(
+            context: OpenAI::Internal::Logging::Context,
+            response: OpenAI::HTTPClient::Response
+          ).returns(T.self_type)
+        end
+        def observe(context:, response:)
+        end
+
         # @api private
         sig { overridable.returns(T::Enumerable[Elem]) }
         private def iterator
@@ -41,9 +54,8 @@ module OpenAI
             model:
               T.any(T::Class[T.anything], OpenAI::Internal::Type::Converter),
             url: URI::Generic,
-            status: Integer,
-            headers: T::Hash[String, String],
-            response: Net::HTTPResponse,
+            response_metadata: OpenAI::ResponseMetadata,
+            response: OpenAI::HTTPClient::Response,
             unwrap:
               T.any(
                 Symbol,
@@ -57,8 +69,7 @@ module OpenAI
         def initialize(
           model:,
           url:,
-          status:,
-          headers:,
+          response_metadata:,
           response:,
           unwrap:,
           stream:

data/rbi/openai/internal/util.rbi

@@ -253,46 +253,6 @@ module OpenAI
         end
       end
 
-      # @api private
-      #
-      # An adapter that satisfies the IO interface required by `::IO.copy_stream`
-      class ReadIOAdapter
-        # @api private
-        sig { returns(T.nilable(T::Boolean)) }
-        def close?
-        end
-
-        # @api private
-        sig { void }
-        def close
-        end
-
-        # @api private
-        sig { params(max_len: T.nilable(Integer)).returns(String) }
-        private def read_enum(max_len)
-        end
-
-        # @api private
-        sig do
-          params(
-            max_len: T.nilable(Integer),
-            out_string: T.nilable(String)
-          ).returns(T.nilable(String))
-        end
-        def read(max_len = nil, out_string = nil)
-        end
-
-        # @api private
-        sig do
-          params(
-            src: T.any(String, Pathname, StringIO, T::Enumerable[String]),
-            blk: T.proc.params(arg0: String).void
-          ).returns(T.attached_class)
-        end
-        def self.new(src, &blk)
-        end
-      end
-
       class << self
         sig do
           params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(
@@ -304,9 +264,15 @@ module OpenAI
       end
 
       JSON_CONTENT =
-        T.let(%r{^application/(?:[a-zA-Z0-9.-]+\+)?json(?!l)}, Regexp)
+        T.let(
+          %r{\Aapplication/(?:[a-z0-9.-]+\+)?json[ \t]*(?:;|\z)}i,
+          Regexp
+        )
       JSONL_CONTENT =
-        T.let(%r{^application/(:?x-(?:n|l)djson)|(:?(?:x-)?jsonl)}, Regexp)
+        T.let(
+          %r{\Aapplication/(?:x-[nl]djson|(?:x-)?jsonl)[ \t]*(?:;|\z)}i,
+          Regexp
+        )
 
       class << self
         # @api private
@@ -346,6 +312,11 @@ module OpenAI
         )
         end
 
+        # @api private
+        sig { params(value: T.any(Pathname, String, Symbol)).returns(String) }
+        private def escape_multipart_header_param(value)
+        end
+
         # @api private
         sig do
           params(
@@ -359,6 +330,19 @@ module OpenAI
         private def write_multipart_chunk(y, boundary:, key:, val:, closing:)
         end
 
+        # @api private
+        sig do
+          params(
+            y: Enumerator::Yielder,
+            boundary: String,
+            key: T.any(Symbol, String),
+            val: T.anything,
+            closing: T::Array[T.proc.void]
+          ).void
+        end
+        private def write_multipart_value(y, boundary:, key:, val:, closing:)
+        end
+
         # @api private
         #
         # https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#special-considerations-for-multipart-content

data/rbi/openai/models/admin/organization/audit_log_list_params.rbi

@@ -646,6 +646,11 @@ module OpenAI
                 :"tenant.workload_identity.principal.provisioned",
                 OpenAI::Admin::Organization::AuditLogListParams::EventType::TaggedSymbol
               )
+            TENANT_WORKLOAD_IDENTITY_ACCESS_TOKEN_ISSUED =
+              T.let(
+                :"tenant.workload_identity.access_token.issued",
+                OpenAI::Admin::Organization::AuditLogListParams::EventType::TaggedSymbol
+              )
             TENANT_ADMIN_API_KEY_CREATED =
               T.let(
                 :"tenant.admin_api_key.created",

data/rbi/openai/models/admin/organization/audit_log_list_response.rbi

@@ -1778,6 +1778,11 @@ module OpenAI
                 :"tenant.workload_identity.principal.provisioned",
                 OpenAI::Models::Admin::Organization::AuditLogListResponse::Type::TaggedSymbol
               )
+            TENANT_WORKLOAD_IDENTITY_ACCESS_TOKEN_ISSUED =
+              T.let(
+                :"tenant.workload_identity.access_token.issued",
+                OpenAI::Models::Admin::Organization::AuditLogListResponse::Type::TaggedSymbol
+              )
             TENANT_ADMIN_API_KEY_CREATED =
               T.let(
                 :"tenant.admin_api_key.created",

data/rbi/openai/models/all_models.rbi

@@ -85,6 +85,21 @@ module OpenAI
             :"gpt-5.1-codex-max",
             OpenAI::AllModels::ResponsesOnlyModel::TaggedSymbol
           )
+        GPT_DAYBREAK_BLUE_LATEST =
+          T.let(
+            :"gpt-daybreak-blue-latest",
+            OpenAI::AllModels::ResponsesOnlyModel::TaggedSymbol
+          )
+        GPT_DAYBREAK_RED_LATEST =
+          T.let(
+            :"gpt-daybreak-red-latest",
+            OpenAI::AllModels::ResponsesOnlyModel::TaggedSymbol
+          )
+        GPT_5_6_CYBER =
+          T.let(
+            :"gpt-5.6-cyber",
+            OpenAI::AllModels::ResponsesOnlyModel::TaggedSymbol
+          )
 
         sig do
           override.returns(