openai 0.82.0 → 0.84.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46609364ce91a3198dceda84c59f20bc29f5bb205f4078289748b41b8df4cdbe
-  data.tar.gz: 749aa50031731341acedf30ef7011cdba8591140cf932eb835793295f2f4328f
+  metadata.gz: 03f5297b1df9de7c2e182a5f76a72a5a15f2e9a34468b554eb92eb7e8022182b
+  data.tar.gz: 414ac43f94cee9591533b94c02d1d904cdd6a6ba0beb8694e88745b1b30dfad6
 SHA512:
-  metadata.gz: dae2c1a9b16e8a6cc0ecca16aa60d0cc1da965a289ba618df760e6bf1a9afa5c9a0333a0c80cb5717957969b86f98506c3fcc0e33b9bc3b2ad47a1dae8a90b79
-  data.tar.gz: 19c8eb602f862152a728350ca05386d7b9ea4951296bd62e3a07313294adc0fbdfe775c25bb04bc41995e5ea2b1ff005e001bcd76b4144a5673b9bdceb7e98a3
+  metadata.gz: a2dda8c58eb47a26113b553b1428d23502d0c6740808954b740c0a5cf5dac361a798f6a14f963cff9d1230256cd800295017dc07489f7c6798f50a59c4066b1c
+  data.tar.gz: 72d931bd9cc9fa963b2f9d0d6f6e66078eb778456097d041850013b814ec20c3b5c9661a4b68c9fa2ea56a829aaaccc657e544a8cb68863f6c9ae4dd653aeb01

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## [0.84.0](https://github.com/openai/openai-ruby/compare/v0.83.0...v0.84.0) (2026-09-02)
+
+
+### Features
+
+* **api:** update usage APIs and documentation ([#566](https://github.com/openai/openai-ruby/issues/566)) ([caac1f0](https://github.com/openai/openai-ruby/commit/caac1f0d0932dff46e25f5879f5a1410425275e9))
+
+
+### Bug Fixes
+
+* accept custom request hash in RBS ([#554](https://github.com/openai/openai-ruby/issues/554)) ([8d32aa1](https://github.com/openai/openai-ruby/commit/8d32aa1764ecff22d2cb3114fa1a4b6f7faa309b))
+* avoid dispatching nil checks during coercion ([#552](https://github.com/openai/openai-ruby/issues/552)) ([c8d6d32](https://github.com/openai/openai-ruby/commit/c8d6d32e178563e38585d3ad928136e3c6f10ac1))
+* avoid duplicate late-choice stream logprobs ([#564](https://github.com/openai/openai-ruby/issues/564)) ([2359a02](https://github.com/openai/openai-ruby/commit/2359a02dd22fbf599250aaa97e755863562abf53))
+* delimit JSONL request records ([#553](https://github.com/openai/openai-ruby/issues/553)) ([dea0408](https://github.com/openai/openai-ruby/commit/dea04081076da3fde34f4a9b15f445dd92556b0f))
+* enforce workload identity request deadlines ([#547](https://github.com/openai/openai-ruby/issues/547)) ([da421b5](https://github.com/openai/openai-ruby/commit/da421b507c24c35f62ff8679dd5c468ce8a0dab9))
+* handle custom chat completion tool calls ([#556](https://github.com/openai/openai-ruby/issues/556)) ([dd49e31](https://github.com/openai/openai-ruby/commit/dd49e31134cf8dd1442f1b3fb428bab4dbc663d1))
+* load YAML for BaseModel serialization ([#555](https://github.com/openai/openai-ruby/issues/555)) ([5420931](https://github.com/openai/openai-ruby/commit/54209313bca8a7159ad8ee4768678ac61b871d69))
+* make error cause contract read-only ([#557](https://github.com/openai/openai-ruby/issues/557)) ([f3169ca](https://github.com/openai/openai-ruby/commit/f3169caae9a6115c3725c8d4da33e9ffb65085c5))
+* preserve formatter path boundaries ([#559](https://github.com/openai/openai-ruby/issues/559)) ([f8b128c](https://github.com/openai/openai-ruby/commit/f8b128cf0db3198a297caec7e7ca8dfa991f16e8))
+* respect StringIO cursor in multipart uploads ([#558](https://github.com/openai/openai-ruby/issues/558)) ([e8ea7c7](https://github.com/openai/openai-ruby/commit/e8ea7c73e7a233abaf7c919ce10117729918df5e))
+* resume Responses streams from server-side cursors ([#548](https://github.com/openai/openai-ruby/issues/548)) ([3b88261](https://github.com/openai/openai-ruby/commit/3b88261e7cd9a8736028c1867c0c23d21aba54b5))
+* support flattened responses typed function tools ([#550](https://github.com/openai/openai-ruby/issues/550)) ([ab16d33](https://github.com/openai/openai-ruby/commit/ab16d33e18c862608125cf12fac07e72702b8752))
+* support structured chat output with typed function tools ([#546](https://github.com/openai/openai-ruby/issues/546)) ([087d1e2](https://github.com/openai/openai-ruby/commit/087d1e2041099342ed59be211259b81dce14392c))
+
+
+### Chores
+
+* **deps-dev:** bump the development-dependencies group with 3 updates ([#560](https://github.com/openai/openai-ruby/issues/560)) ([f728e07](https://github.com/openai/openai-ruby/commit/f728e072a0d65e2d66b2e647d36843b76fd92606))
+
+## [0.83.0](https://github.com/openai/openai-ruby/compare/v0.82.0...v0.83.0) (2026-08-27)
+
+
+### Features
+
+* **api:** add compute_units to Responses and Chat Completions usage ([#543](https://github.com/openai/openai-ruby/issues/543)) ([b128f89](https://github.com/openai/openai-ruby/commit/b128f89672416a083addeb0e2bbc337f8ddb7f9f))
+* expose opt-in raw response bodies on response metadata ([#544](https://github.com/openai/openai-ruby/issues/544)) ([1529e96](https://github.com/openai/openai-ruby/commit/1529e96781c217828915ed3f69faa61bf6605129))
+
+
+### Bug Fixes
+
+* **realtime:** clean up interrupted WebRTC call allocations ([#534](https://github.com/openai/openai-ruby/issues/534)) ([2057039](https://github.com/openai/openai-ruby/commit/205703935bafe5e78b90b5424cc43d3b7b978772))
+
+
+### Chores
+
+* **deps:** bump the codeql group with 2 updates ([#541](https://github.com/openai/openai-ruby/issues/541)) ([b15451c](https://github.com/openai/openai-ruby/commit/b15451c0df8ba890f136c86dc7f5299876bb9b5d))
+
 ## [0.82.0](https://github.com/openai/openai-ruby/compare/v0.81.0...v0.82.0) (2026-08-27)
 
 

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openai", "~> 0.82.0"
+gem "openai", "~> 0.84.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/openai/auth/workload_identity_auth.rb

@@ -15,6 +15,12 @@ module OpenAI
       DEFAULT_REFRESH_BUFFER_SECONDS = 1200
       MAX_REJECTED_TOKEN_REFRESH_ATTEMPTS = 3
       private_constant :MAX_REJECTED_TOKEN_REFRESH_ATTEMPTS
+      # Provider implementations wrap StandardError, but scheduler deadlines
+      # must cross that boundary before normalization to Timeout::Error.
+      # rubocop:disable Lint/InheritException
+      PROVIDER_DEADLINE_ERROR = Class.new(Exception)
+      # rubocop:enable Lint/InheritException
+      private_constant :PROVIDER_DEADLINE_ERROR
 
       def initialize(
         config,
@@ -274,10 +280,19 @@ module OpenAI
       private def fetch_token_from_exchange(deadline:)
         return @token_exchange.fetch(deadline: deadline) unless @token_exchange.nil?
 
-        subject_token = @config.provider.get_token
+        message = "request timed out during workload identity authentication"
+        subject_token, token_type = begin
+          timeout = remaining_timeout(deadline)
+          Timeout.timeout(timeout, PROVIDER_DEADLINE_ERROR, message) do
+            [@config.provider.get_token, @config.provider.token_type]
+          end
+
+        rescue PROVIDER_DEADLINE_ERROR
+          raise Timeout::Error, message
+        end
+
         check_deadline!(deadline)
 
-        token_type = @config.provider.token_type
         subject_token_type = SUBJECT_TOKEN_TYPES.fetch(token_type) do
           raise(
             ArgumentError,

data/lib/openai/client.rb

@@ -18,6 +18,8 @@ module OpenAI
     DEFAULT_MAX_RETRY_DELAY = 8.0
 
     WORKLOAD_IDENTITY_API_KEY_PLACEHOLDER = "workload-identity-auth"
+    WORKLOAD_IDENTITY_DEADLINE_ERROR = Class.new(Timeout::Error)
+    private_constant :WORKLOAD_IDENTITY_DEADLINE_ERROR
 
     # @return [String, nil]
     attr_reader :api_key
@@ -248,9 +250,9 @@ module OpenAI
 
     # @api private
     private def validate_retry_delay!(request, delay:)
-      deadline = request[:x509_request_context]&.fetch(:deadline)
+      deadline = request[:x509_request_context]&.fetch(:deadline) || request[:workload_identity_deadline]
       if deadline && delay >= deadline - OpenAI::Internal::Util.monotonic_secs
-        raise Timeout::Error, "request timed out during workload identity authentication"
+        raise WORKLOAD_IDENTITY_DEADLINE_ERROR, "request timed out during workload identity authentication"
       end
 
       super
@@ -281,7 +283,8 @@ module OpenAI
           request[:workload_identity_deadline] ||
           request[:timeout]&.then { OpenAI::Internal::Util.monotonic_secs + _1 }
       else
-        request[:timeout]&.then { OpenAI::Internal::Util.monotonic_secs + _1 }
+        request[:workload_identity_deadline] ||
+          request[:timeout]&.then { OpenAI::Internal::Util.monotonic_secs + _1 }
       end
 
       request = request.merge(workload_identity_deadline: deadline)
@@ -359,8 +362,16 @@ module OpenAI
         end
       end
 
-    rescue Timeout::Error
-      raise unless x509_request
+    rescue Timeout::Error => error
+      unless x509_request
+        raise unless error.is_a?(WORKLOAD_IDENTITY_DEADLINE_ERROR)
+
+        url = request.fetch(:url).dup
+        url.query = nil
+        url.fragment = nil
+        cause = Timeout::Error.new(error.message)
+        raise OpenAI::Errors::APITimeoutError.new(url: url, message: error.message), cause: cause
+      end
 
       url = request.fetch(:url).dup
       url.query = nil
@@ -443,7 +454,10 @@ module OpenAI
     rescue Timeout::Error => e
       raise if x509_transport?(@requester)
 
-      raise OpenAI::Errors::APITimeoutError.new(url: request.fetch(:url), message: e.message)
+      url = request.fetch(:url).dup
+      url.query = nil
+      url.fragment = nil
+      raise OpenAI::Errors::APITimeoutError.new(url: url, message: e.message)
     end
 
     # @api private

data/lib/openai/errors.rb

@@ -3,7 +3,7 @@
 module OpenAI
   module Errors
     class Error < StandardError
-      # @!attribute cause
+      # @!attribute [r] cause
       #
       #   @return [StandardError, nil]
     end

data/lib/openai/helpers/realtime/client_extension.rb

@@ -5,6 +5,113 @@ module OpenAI
     module Realtime
       # Realtime request integration kept outside the generated client implementation.
       module ClientExtension
+        MAX_CALL_CLEANUP_SECONDS = 5.0
+        private_constant :MAX_CALL_CLEANUP_SECONDS
+
+        # A generated WebRTC allocation belongs to the SDK until its complete raw
+        # response can be returned. Keep this lifecycle outside generated resources.
+        def request(req)
+          unless req.is_a?(Hash) &&
+              req[:method] == :post &&
+              req[:path] == "realtime/calls" &&
+              req[:model] == OpenAI::HTTPClient::Response
+            return super
+          end
+
+          delivered = false
+          allocated_response = nil
+          call_id = nil
+          begin
+            url, response, log_context = perform_request(req) do |received_response, request_url, response_url|
+              if received_response.status == 201
+                allocated_response = received_response
+                if response_url.path == request_url.path &&
+                    realtime_call_origin(response_url).casecmp?(realtime_call_origin(request_url))
+                  call_id = realtime_call_id_from_location(
+                    received_response.headers["location"],
+                    request_url: request_url
+                  )
+                end
+              end
+            end
+
+            result = finish_request(log_context, response) do
+              parse_response(req, url: url, response: response)
+            end
+
+            delivered = true
+            result
+          ensure
+            unless delivered
+              begin
+                OpenAI::Internal::Util.close_fused!(allocated_response.body) if allocated_response
+              rescue StandardError, *(defined?(::Async::Stop) ? [::Async::Stop] : [])
+                nil
+              ensure
+                cleanup_created_realtime_call(call_id, options: req[:options]) if call_id
+              end
+            end
+          end
+        end
+
+        private def realtime_call_id_from_location(location, request_url:)
+          return if location.nil? || location.empty?
+
+          call_url = URI.join(request_url.to_s, location)
+          unless call_url.is_a?(URI::HTTP) &&
+              !call_url.host.to_s.empty? &&
+              call_url.userinfo.nil? &&
+              call_url.fragment.nil?
+            return
+          end
+
+          return unless realtime_call_origin(request_url).casecmp?(realtime_call_origin(call_url))
+
+          prefix = "#{request_url.path}/"
+          return unless call_url.path.start_with?(prefix)
+
+          call_id = call_url.path.delete_prefix(prefix)
+          call_id if /\A[A-Za-z0-9_-]+\z/.match?(call_id)
+        rescue URI::InvalidURIError, ArgumentError
+          nil
+        end
+
+        private def realtime_call_origin(url)
+          origin = OpenAI::Internal::Util.uri_origin(url)
+          if url.host.start_with?("[") && !url.hostname.start_with?("v", "V")
+            origin = origin.sub(url.host, "[#{IPAddr.new(url.hostname)}]")
+          end
+
+          origin
+        end
+
+        private def cleanup_created_realtime_call(call_id, options:)
+          cleanup_options = options.to_h.slice(:extra_headers, :extra_query, :timeout)
+          timeout = cleanup_options.fetch(:timeout, @timeout)
+          timeout = MAX_CALL_CLEANUP_SECONDS unless timeout&.positive?
+          cleanup_options[:timeout] = [timeout, MAX_CALL_CLEANUP_SECONDS].min
+          cleanup_options[:max_retries] = 0
+          task = ::Async::Task.current? if defined?(::Async::Task)
+          cleanup = lambda do
+            Timeout.timeout(cleanup_options.fetch(:timeout)) do
+              realtime.calls.hangup(call_id, request_options: cleanup_options)
+            end
+          end
+
+          if task
+            if task.respond_to?(:defer_cancel)
+              task.defer_cancel(&cleanup)
+            else
+              task.defer_stop(&cleanup)
+            end
+          else
+            cleanup.call
+          end
+
+        rescue StandardError, *(defined?(::Async::Stop) ? [::Async::Stop] : [])
+          nil
+        end
+
         # Build a fully authenticated Realtime WebSocket handshake request. Realtime
         # transports use this boundary so provider authentication and request options stay
         # consistent with ordinary SDK requests.

data/lib/openai/helpers/streaming/chat_completion_stream.rb

@@ -156,6 +156,7 @@ module OpenAI
             insert_choice_snapshot!(completion_snapshot.choices, choice_snapshot)
           else
             update_existing_choice_snapshot(choice, choice_snapshot)
+            accumulate_logprobs!(choice.logprobs, choice_snapshot)
           end
 
           tool_calls_by_index = index_choice_snapshot!(choice_snapshot)
@@ -166,8 +167,6 @@ module OpenAI
           end
 
           parse_tool_calls!(choice.delta.tool_calls, tool_calls_by_index)
-
-          accumulate_logprobs!(choice.logprobs, choice_snapshot)
         end
 
         def create_new_choice_snapshot(choice)

data/lib/openai/helpers/streaming/response_events.rb

@@ -4,7 +4,7 @@ module OpenAI
   module Helpers
     module Streaming
       class ResponseTextDeltaEvent < OpenAI::Models::Responses::ResponseTextDeltaEvent
-        required :snapshot, String
+        optional :snapshot, String, nil?: true
       end
 
       class ResponseTextDoneEvent < OpenAI::Models::Responses::ResponseTextDoneEvent
@@ -12,7 +12,7 @@ module OpenAI
       end
 
       class ResponseFunctionCallArgumentsDeltaEvent < OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
-        required :snapshot, String
+        optional :snapshot, String, nil?: true
       end
 
       class ResponseCompletedEvent < OpenAI::Models::Responses::ResponseCompletedEvent

data/lib/openai/helpers/streaming/response_stream.rb

@@ -13,7 +13,8 @@ module OpenAI
           @last_response = raw_stream.last_response
           @iterator = iterator
           @state = ResponseStreamState.new(
-            text_format: text_format
+            text_format: text_format,
+            starting_after: starting_after
           )
         end
 
@@ -26,7 +27,7 @@ module OpenAI
           OpenAI::Internal::Util.chain_fused(@iterator) do |yielder|
             @iterator.each do |event|
               case event
-              when OpenAI::Streaming::ResponseTextDeltaEvent
+              when OpenAI::Models::Responses::ResponseTextDeltaEvent
                 yielder << event.delta
               end
             end
@@ -80,10 +81,11 @@ module OpenAI
       class ResponseStreamState
         attr_reader :completed_response
 
-        def initialize(text_format:)
+        def initialize(text_format:, starting_after: nil)
           @current_snapshot = nil
           @completed_response = nil
           @text_format = text_format
+          @resumed = !starting_after.nil?
         end
 
         def handle_event(event)
@@ -98,31 +100,43 @@ module OpenAI
 
           case event
           when OpenAI::Models::Responses::ResponseTextDeltaEvent
-            output = @current_snapshot.output[event.output_index]
-            assert_type(output, :message)
+            if @current_snapshot
+              output = @current_snapshot.output[event.output_index]
+              assert_type(output, :message)
 
-            content = output.content[event.content_index]
-            assert_type(content, :output_text)
-
-            events_to_yield <<
-              OpenAI::Streaming::ResponseTextDeltaEvent.new(
-                content_index: event.content_index,
-                delta: event.delta,
-                item_id: event.item_id,
-                output_index: event.output_index,
-                sequence_number: event.sequence_number,
-                type: event.type,
-                snapshot: content.text
-              )
+              content = output.content[event.content_index]
+              assert_type(content, :output_text)
+              events_to_yield <<
+                OpenAI::Streaming::ResponseTextDeltaEvent.new(
+                  content_index: event.content_index,
+                  delta: event.delta,
+                  item_id: event.item_id,
+                  output_index: event.output_index,
+                  sequence_number: event.sequence_number,
+                  type: event.type,
+                  snapshot: content.text
+                )
+            else
+              # A server-directed resumed stream may begin after response.created.
+              # Without the omitted prefix, a snapshot would be incomplete and
+              # materializing every partial prefix would make streaming quadratic.
+              events_to_yield <<
+                OpenAI::Streaming::ResponseTextDeltaEvent.new(event.to_h.merge(snapshot: nil))
+            end
 
           when OpenAI::Models::Responses::ResponseTextDoneEvent
-            output = @current_snapshot.output[event.output_index]
-            assert_type(output, :message)
+            text = if @current_snapshot
+              output = @current_snapshot.output[event.output_index]
+              assert_type(output, :message)
 
-            content = output.content[event.content_index]
-            assert_type(content, :output_text)
+              content = output.content[event.content_index]
+              assert_type(content, :output_text)
+              content.text
+            else
+              event.text
+            end
 
-            parsed = parse_structured_text(content.text)
+            parsed = parse_structured_text(text)
 
             events_to_yield <<
               OpenAI::Streaming::ResponseTextDoneEvent.new(
@@ -136,18 +150,26 @@ module OpenAI
               )
 
           when OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
-            output = @current_snapshot.output[event.output_index]
-            assert_type(output, :function_call)
-
-            events_to_yield <<
-              OpenAI::Streaming::ResponseFunctionCallArgumentsDeltaEvent.new(
-                delta: event.delta,
-                item_id: event.item_id,
-                output_index: event.output_index,
-                sequence_number: event.sequence_number,
-                type: event.type,
-                snapshot: output.arguments
-              )
+            if @current_snapshot
+              output = @current_snapshot.output[event.output_index]
+              assert_type(output, :function_call)
+              events_to_yield <<
+                OpenAI::Streaming::ResponseFunctionCallArgumentsDeltaEvent.new(
+                  delta: event.delta,
+                  item_id: event.item_id,
+                  output_index: event.output_index,
+                  sequence_number: event.sequence_number,
+                  type: event.type,
+                  snapshot: output.arguments
+                )
+            else
+              # See the text-delta branch above: a partial server resume has no
+              # complete argument prefix from which to build a truthful snapshot.
+              events_to_yield <<
+                OpenAI::Streaming::ResponseFunctionCallArgumentsDeltaEvent.new(
+                  event.to_h.merge(snapshot: nil)
+                )
+            end
 
           when OpenAI::Models::Responses::ResponseCompletedEvent
             events_to_yield <<
@@ -167,16 +189,25 @@ module OpenAI
 
         def accumulate_event(event:, current_snapshot:)
           if current_snapshot.nil?
-            unless event.is_a?(OpenAI::Models::Responses::ResponseCreatedEvent)
+            if event.is_a?(OpenAI::Models::Responses::ResponseCreatedEvent)
+              # Use the converter to create a new, isolated copy of the response object.
+              # This ensures proper type validation and prevents shared object references.
+              return OpenAI::Internal::Type::Converter.coerce(
+                OpenAI::Models::Responses::Response,
+                event.response
+              )
+            end
+
+            unless @resumed
               raise "Expected first event to be response.created"
             end
 
-            # Use the converter to create a new, isolated copy of the response object.
-            # This ensures proper type validation and prevents shared object references.
-            return OpenAI::Internal::Type::Converter.coerce(
-              OpenAI::Models::Responses::Response,
-              event.response
-            )
+            if event.is_a?(OpenAI::Models::Responses::ResponseCompletedEvent)
+              @completed_response = event.response
+              return event.response
+            end
+
+            return nil
           end
 
           case event

data/lib/openai/helpers/structured_output/chat_completion_parser.rb

@@ -28,6 +28,8 @@ module OpenAI
 
             raw[:choices]&.each do |choice|
               choice.dig(:message, :tool_calls)&.each do |tool_call|
+                next if tool_call[:type] == "custom"
+
                 func = tool_call.fetch(:function)
                 next if (model = tool_models[func.fetch(:name)]).nil?
 
@@ -81,6 +83,10 @@ module OpenAI
                 }
             }
             parsed.dig(:response_format, :json_schema).store(:schema, model.to_json_schema)
+          else
+          end
+
+          case parsed
           in {tools: Array => tools}
             mapped = tools.map do |tool|
               case tool

data/lib/openai/helpers/structured_output/response_parser.rb

@@ -109,7 +109,7 @@ module OpenAI
                   parameters: tool.to_json_schema
                 }
               in {type: :function, parameters: OpenAI::StructuredOutput::JsonSchemaConverter => params}
-                func = tool.fetch(:function)
+                func = tool.fetch(:function, tool)
                 name = func[:name] ||= params.name.split("::").last
                 tool_models.store(name, params)
                 func.update(parameters: params.to_json_schema)

data/lib/openai/http_client.rb

@@ -20,11 +20,18 @@ module OpenAI
     # @return [String, nil]
     attr_reader :request_id
 
+    # The exact response body when `include_raw_body: true` was requested.
+    # Bodies are never retained by default or for streaming responses.
+    #
+    # @return [String, nil]
+    attr_reader :body
+
     # @api private
     #
     # @param status [Integer]
     # @param headers [Hash{String=>String}]
-    def initialize(status:, headers:)
+    # @param body [String, nil]
+    def initialize(status:, headers:, body: nil)
       @status = Integer(status)
       @headers = headers
         .to_h do |name, value|
@@ -32,6 +39,7 @@ module OpenAI
         end
         .freeze
       @request_id = @headers["x-request-id"]
+      @body = body.nil? || body.frozen? ? body : body.dup.freeze
       freeze
     end
 
@@ -39,6 +47,37 @@ module OpenAI
     #
     # @return [String]
     def inspect = "#<#{self.class} status=#{@status} request_id=#{@request_id.inspect}>"
+
+    # Keep retained response bodies out of Psych object serialization.
+    #
+    # @api private
+    # @param coder [Psych::Coder]
+    # @return [void]
+    def encode_with(coder)
+      coder["status"] = @status
+      coder["headers"] = @headers
+    end
+
+    # @api private
+    # @param coder [Psych::Coder]
+    # @return [void]
+    def init_with(coder)
+      initialize(status: coder["status"], headers: coder["headers"])
+    end
+
+    # Keep retained response bodies out of Marshal object serialization.
+    #
+    # @api private
+    # @return [Array(Integer, Hash{String=>String})]
+    def marshal_dump = [@status, @headers]
+
+    # @api private
+    # @param values [Array(Integer, Hash{String=>String})]
+    # @return [void]
+    def marshal_load(values)
+      status, headers = values
+      initialize(status: status, headers: headers)
+    end
   end
 
   # Details about an API request retry that is about to run.

data/lib/openai/internal/logging.rb

@@ -26,19 +26,24 @@ module OpenAI
       URL_HEADER_KEY = /(?:\A|[-_])(?:location|url|uri)\z|\A(?:link|refresh)\z/i
 
       class Context
-        def initialize(logger:, log_level:, on_retry:, method:, url:)
+        def initialize(logger:, log_level:, on_retry:, method:, url:, on_response: nil)
           @logger = logger
           @log_level = log_level
           @on_retry = on_retry
+          @on_response = on_response
           @id = nil
           @method = method.to_s.upcase
           @url = url
+          @request_url = url
+          @first_request_url = nil
           @started_at = OpenAI::Internal::Util.monotonic_secs
           @attempt_started_at = @started_at
           @attempts = 0
         end
 
         def request_started(request, redirect_count:)
+          @request_url = request.url
+          @first_request_url ||= request.url
           @attempts += 1
           log(:debug) do
             "[openai] request started log_id=#{id} attempt=#{@attempts} " \
@@ -52,6 +57,7 @@ module OpenAI
         end
 
         def response_received(response)
+          @on_response&.call(response, @first_request_url || @url, @request_url)
           log(:debug) do
             "[openai] response received log_id=#{id} attempt=#{@attempts} " \
               "status=#{response.status} request_id=#{safe_field(response.headers["x-request-id"])} " \