openai 0.80.0 → 0.82.0

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

@@ -63,13 +63,18 @@ module OpenAI
             @raw_stream.each do |raw_event|
               events_to_yield = @state.handle_event(raw_event)
               events_to_yield.each do |event|
-                if @starting_after.nil? || event.sequence_number > @starting_after
-                  y << event
-                end
+                y << event if after_starting_event?(event)
               end
             end
           end
         end
+
+        def after_starting_event?(event)
+          return true if @starting_after.nil?
+          return true if event.is_a?(UnknownStreamEvent) && event.sequence_number.nil?
+
+          event.sequence_number > @starting_after
+        end
       end
 
       class ResponseStreamState
@@ -82,6 +87,8 @@ module OpenAI
         end
 
         def handle_event(event)
+          return [event] if event.is_a?(UnknownStreamEvent)
+
           @current_snapshot = accumulate_event(
             event: event,
             current_snapshot: @current_snapshot
@@ -97,15 +104,16 @@ module OpenAI
             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
-            )
+            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
+              )
 
           when OpenAI::Models::Responses::ResponseTextDoneEvent
             output = @current_snapshot.output[event.output_index]
@@ -116,35 +124,38 @@ module OpenAI
 
             parsed = parse_structured_text(content.text)
 
-            events_to_yield << OpenAI::Streaming::ResponseTextDoneEvent.new(
-              content_index: event.content_index,
-              item_id: event.item_id,
-              output_index: event.output_index,
-              sequence_number: event.sequence_number,
-              text: event.text,
-              type: event.type,
-              parsed: parsed
-            )
+            events_to_yield <<
+              OpenAI::Streaming::ResponseTextDoneEvent.new(
+                content_index: event.content_index,
+                item_id: event.item_id,
+                output_index: event.output_index,
+                sequence_number: event.sequence_number,
+                text: event.text,
+                type: event.type,
+                parsed: parsed
+              )
 
           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
-            )
+            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
+              )
 
           when OpenAI::Models::Responses::ResponseCompletedEvent
-            events_to_yield << OpenAI::Streaming::ResponseCompletedEvent.new(
-              sequence_number: event.sequence_number,
-              type: event.type,
-              response: event.response
-            )
+            events_to_yield <<
+              OpenAI::Streaming::ResponseCompletedEvent.new(
+                sequence_number: event.sequence_number,
+                type: event.type,
+                response: event.response
+              )
 
           else
             # Pass through other events unchanged.
@@ -219,8 +230,10 @@ module OpenAI
             parsed = JSON.parse(text, symbolize_names: true)
             OpenAI::Internal::Type::Converter.coerce(@text_format, parsed)
           rescue JSON::ParserError => e
-            raise "Failed to parse structured text as JSON for #{@text_format}: #{e.message}. " \
-                  "Raw text: #{text.inspect}"
+            raise(
+              "Failed to parse structured text as JSON for #{@text_format}: #{e.message}. " \
+                "Raw text: #{text.inspect}"
+            )
           end
         end
       end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Helpers
+    module Streaming
+      # A Responses event whose discriminator is newer than this SDK version.
+      class UnknownStreamEvent
+        # @return [Symbol]
+        attr_reader :type
+
+        # @return [Integer, nil]
+        attr_reader :sequence_number
+
+        # @return [Hash{Symbol=>Object}]
+        attr_reader :data
+
+        # @api private
+        def initialize(data:)
+          value = data.fetch(:type)
+          unless value.is_a?(String) || value.is_a?(Symbol)
+            raise ArgumentError, "Responses stream event type must be a string or symbol"
+          end
+
+          @type = value.to_sym
+          sequence_number = data[:sequence_number]
+          @sequence_number = sequence_number if sequence_number.is_a?(Integer)
+          @data = freeze_json(data)
+          freeze
+        end
+
+        # @return [Hash{Symbol=>Object}]
+        def to_h = @data
+
+        private def freeze_json(value)
+          case value
+          when Hash
+            value.each do |key, item|
+              freeze_json(key)
+              freeze_json(item)
+            end
+
+          when Array
+            value.each { |item| freeze_json(item) }
+          end
+
+          value.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -60,9 +60,7 @@ module OpenAI
 
         class << self
           def optional(...)
-            message =
-              "`optional` is not supported for structured output APIs, " \
-              "use `#required` with `nil?: true` instead"
+            message = "`optional` is not supported for structured output APIs, use `#required` with `nil?: true` instead"
             raise message
           end
         end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Helpers
+    module StructuredOutput
+      # Request preparation and response coercion for Chat Completions.
+      #
+      # @api private
+      module ChatCompletionParser
+        # @api private
+        def self.build_unwrap(model, tool_models)
+          # rubocop:disable Metrics/BlockLength
+          -> (raw) do
+            if model.is_a?(OpenAI::StructuredOutput::JsonSchemaConverter)
+              raw[:choices]&.each do |choice|
+                message = choice.fetch(:message)
+                begin
+                  content = message.fetch(:content)
+                  parsed = content.nil? ? nil : JSON.parse(content, symbolize_names: true)
+                rescue JSON::ParserError => e
+                  parsed = e
+                end
+
+                coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
+                message.store(:parsed, coerced)
+              end
+            end
+
+            raw[:choices]&.each do |choice|
+              choice.dig(:message, :tool_calls)&.each do |tool_call|
+                func = tool_call.fetch(:function)
+                next if (model = tool_models[func.fetch(:name)]).nil?
+
+                begin
+                  arguments = func.fetch(:arguments)
+                  parsed = arguments.nil? ? nil : JSON.parse(arguments, symbolize_names: true)
+                rescue JSON::ParserError => e
+                  parsed = e
+                end
+
+                coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
+                func.store(:parsed, coerced)
+              end
+            end
+
+            raw
+          end
+          # rubocop:enable Metrics/BlockLength
+        end
+
+        # @api private
+        def self.get_models(parsed)
+          model = nil
+          tool_models = {}
+          case parsed
+          in {response_format: OpenAI::StructuredOutput::JsonSchemaConverter => model}
+            parsed.update(
+              response_format: {
+                type: :json_schema,
+                json_schema: {
+                  strict: true,
+                  name: model.name.split("::").last,
+                  schema: model.to_json_schema
+                }
+              }
+            )
+          in {
+              response_format: {type: :json_schema, json_schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}
+            }
+            parsed.fetch(:response_format).update(
+              json_schema: {
+                strict: true,
+                name: model.name.split("::").last,
+                schema: model.to_json_schema
+              }
+            )
+          in {
+              response_format: {
+                  type: :json_schema,
+                  json_schema: {schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}
+                }
+            }
+            parsed.dig(:response_format, :json_schema).store(:schema, model.to_json_schema)
+          in {tools: Array => tools}
+            mapped = tools.map do |tool|
+              case tool
+              in OpenAI::StructuredOutput::JsonSchemaConverter
+                name = tool.name.split("::").last
+                tool_models.store(name, tool)
+                {
+                  type: :function,
+                  function: {
+                    strict: true,
+                    name: name,
+                    parameters: tool.to_json_schema
+                  }
+                }
+              in {function: {parameters: OpenAI::StructuredOutput::JsonSchemaConverter => params}}
+                func = tool.fetch(:function)
+                name = func[:name] ||= params.name.split("::").last
+                tool_models.store(name, params)
+                func.update(parameters: params.to_json_schema)
+                tool
+              else
+                tool
+              end
+            end
+
+            tools.replace(mapped)
+          else
+          end
+
+          [model, tool_models]
+        end
+
+        # @api private
+        def self.build_tools(tools, tool_models)
+          return [] if tools.nil?
+
+          tools.map do |tool|
+            next tool unless tool[:type] == :function
+
+            function_name = tool.dig(:function, :name)
+            model = tool_models[function_name]
+
+            model ? tool.merge(model: model) : tool
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,20 +25,21 @@ module OpenAI
         # @return [Hash{Symbol=>Object}]
         def to_json_schema_inner(state:)
           OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.cache_def!(state, type: self) do
-            types = values.map do
-              case _1
-              in NilClass
-                "null"
-              in true | false
-                "boolean"
-              in Integer
-                "integer"
-              in Float
-                "number"
-              in Symbol
-                "string"
+            types = values
+              .map do
+                case _1
+                in NilClass
+                  "null"
+                in true | false
+                  "boolean"
+                in Integer
+                  "integer"
+                in Float
+                  "number"
+                in Symbol
+                  "string"
+                end
               end
-            end
               .uniq
 
             {

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

@@ -6,17 +6,23 @@ module OpenAI
       # To customize the JSON schema conversion for a type, implement the `JsonSchemaConverter` interface.
       module JsonSchemaConverter
         # @api private
-        POINTERS = Object.new.tap do
-          _1.define_singleton_method(:inspect) do
-            "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::POINTERS>"
+        POINTERS = Object
+          .new
+          .tap do
+            _1.define_singleton_method(:inspect) do
+              "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::POINTERS>"
+            end
           end
-        end.freeze
+          .freeze
         # @api private
-        NO_REF = Object.new.tap do
-          _1.define_singleton_method(:inspect) do
-            "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::NO_REF>"
+        NO_REF = Object
+          .new
+          .tap do
+            _1.define_singleton_method(:inspect) do
+              "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::NO_REF>"
+            end
           end
-        end.freeze
+          .freeze
 
         # rubocop:disable Lint/UnusedMethodArgument
 
@@ -68,6 +74,7 @@ module OpenAI
             if schema.key?(:$ref) && !xformed.empty?
               schema.merge!(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF => true)
             end
+
             schema.merge!(xformed)
           end
 
@@ -140,6 +147,7 @@ module OpenAI
                 end
               else
               end
+
               no_refs.each { _1.replace(_1.except(:$ref).merge(sch)) }
             end
 
@@ -147,6 +155,7 @@ module OpenAI
               pointer_token = URI::RFC2396_PARSER.unescape(_1.delete_prefix("#/$defs/"))
               pointer_token.gsub("~1", "/").gsub("~0", "~")
             end
+
             xformed.empty? ? schema : {"$defs": xformed}.update(schema)
           end
 
@@ -179,6 +188,7 @@ module OpenAI
                 return {type: "string"}
               else
               end
+
             in _ if OpenAI::Internal::Util.primitive?(type)
               return {const: type.is_a?(Symbol) ? type.to_s : type}
             else
@@ -196,10 +206,7 @@ module OpenAI
               OpenAI::UnionOf
               OpenAI::BaseModel
             ]
-            message =
-              "#{type} does not implement the " \
-              "#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter} interface. " \
-              "Please use one of the supported types: #{models}"
+            message = "#{type} does not implement the #{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter} interface. Please use one of the supported types: #{models}"
             raise ArgumentError.new(message)
           end
         end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Helpers
+    module StructuredOutput
+      # Request preparation and response coercion for the Responses API.
+      #
+      # @api private
+      module ResponseParser
+        # Post-processes raw API responses to parse and coerce structured outputs into typed Ruby objects.
+        #
+        # @api private
+        #
+        # @param raw [Hash] The raw API response hash that will be mutated with parsed data
+        # @param model [JsonSchemaConverter, nil] The converter for structured text output
+        # @param tool_models [Hash<String, JsonSchemaConverter>] Tool names and their converters
+        # @return [Hash] The same response with typed values in its :parsed fields
+        def self.parse!(raw, model, tool_models)
+          if model.is_a?(OpenAI::StructuredOutput::JsonSchemaConverter)
+            raw[:output]
+              &.flat_map do |output|
+                next [] unless output[:type] == "message"
+                output[:content].to_a
+              end
+              &.each do |content|
+                next unless content[:type] == "output_text"
+                begin
+                  parsed = JSON.parse(content.fetch(:text), symbolize_names: true)
+                rescue JSON::ParserError => e
+                  parsed = e
+                end
+
+                coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
+                content.store(:parsed, coerced)
+              end
+          end
+
+          raw[:output]&.each do |output|
+            next unless output[:type] == "function_call"
+            next if (model = tool_models[output.fetch(:name)]).nil?
+            begin
+              parsed = JSON.parse(output.fetch(:arguments), symbolize_names: true)
+            rescue JSON::ParserError => e
+              parsed = e
+            end
+
+            coerced = OpenAI::Internal::Type::Converter.coerce(model, parsed)
+            output.store(:parsed, coerced)
+          end
+
+          raw
+        end
+
+        # Extracts structured output models and replaces request values with JSON Schema.
+        #
+        # @api private
+        #
+        # @param parsed [Hash] Request parameters to update in place
+        # @return [Array<(JsonSchemaConverter|nil, Hash)>] Text model and named tool models
+        def self.get_models(parsed)
+          model = nil
+          tool_models = {}
+
+          case parsed
+          in {text: OpenAI::StructuredOutput::JsonSchemaConverter => model}
+            parsed.update(
+              text: {
+                format: {
+                  type: :json_schema,
+                  strict: true,
+                  name: model.name.split("::").last,
+                  schema: model.to_json_schema
+                }
+              }
+            )
+          in {text: {format: OpenAI::StructuredOutput::JsonSchemaConverter => model}}
+            parsed.fetch(:text).update(
+              format: {
+                type: :json_schema,
+                strict: true,
+                name: model.name.split("::").last,
+                schema: model.to_json_schema
+              }
+            )
+          in {
+              text: {
+                  format: {
+                      type: :json_schema,
+                      schema: OpenAI::StructuredOutput::JsonSchemaConverter => model
+                    }
+                }
+            }
+            parsed.dig(:text, :format).store(:schema, model.to_json_schema)
+          else
+          end
+
+          case parsed
+          in {tools: Array => tools}
+            # rubocop:disable Metrics/BlockLength
+            mapped = tools.map do |tool|
+              case tool
+              in OpenAI::StructuredOutput::JsonSchemaConverter
+                name = tool.name.split("::").last
+                tool_models.store(name, tool)
+                {
+                  type: :function,
+                  strict: true,
+                  name: name,
+                  parameters: tool.to_json_schema
+                }
+              in {type: :function, parameters: OpenAI::StructuredOutput::JsonSchemaConverter => params}
+                func = tool.fetch(:function)
+                name = func[:name] ||= params.name.split("::").last
+                tool_models.store(name, params)
+                func.update(parameters: params.to_json_schema)
+                tool
+              in {type: _, function: {parameters: OpenAI::StructuredOutput::JsonSchemaConverter => params, **}}
+                name = tool[:function][:name] || params.name.split("::").last
+                tool_models.store(name, params)
+                tool[:function][:parameters] = params.to_json_schema
+                tool
+              in {type: _, function: Hash => func}
+                params = func[:parameters]
+                # rubyfmt 0.14.1 corrupts a long guarded `in` clause into `in if`.
+                # Keep the same guard in the existing handwritten branch instead.
+                next tool unless params.is_a?(Class) && params < OpenAI::Internal::Type::BaseModel
+                name = func[:name] || params.name.split("::").last
+                tool_models.store(name, params)
+                func[:parameters] = params.to_json_schema
+                tool
+              else
+                tool
+              end
+            end
+            # rubocop:enable Metrics/BlockLength
+            tools.replace(mapped)
+          else
+          end
+
+          [model, tool_models]
+        end
+      end
+    end
+  end
+end

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

@@ -38,6 +38,7 @@ module OpenAI
                 mergeable_keys[_1] += 1 if schema.keys == _1 && schema[_1].is_a?(Array)
               end
             end
+
             mergeable = mergeable_keys.any? { _1.last == schemas.length }
             if mergeable
               OpenAI::Internal::Util.deep_merge(*schemas, concat: true)

data/lib/openai/http_client.rb

@@ -26,13 +26,19 @@ module OpenAI
     # @param headers [Hash{String=>String}]
     def initialize(status:, headers:)
       @status = Integer(status)
-      @headers =
-        headers.to_h do |name, value|
+      @headers = headers
+        .to_h do |name, value|
           [name.to_s.downcase.freeze, value.to_s.dup.freeze]
-        end.freeze
+        end
+        .freeze
       @request_id = @headers["x-request-id"]
       freeze
     end
+
+    # Inspect metadata without exposing sensitive response headers.
+    #
+    # @return [String]
+    def inspect = "#<#{self.class} status=#{@status} request_id=#{@request_id.inspect}>"
   end
 
   # Details about an API request retry that is about to run.
@@ -167,8 +173,14 @@ module OpenAI
             OpenAI::Internal::Util.close_fused!(source)
           end
         end
+
         freeze
       end
+
+      # Inspect response metadata without exposing sensitive headers or body content.
+      #
+      # @return [String]
+      def inspect = "#<#{self.class} status=#{@status} request_id=#{@metadata.request_id.inspect}>"
     end
 
     # Executes one SDK-prepared HTTP request.

data/lib/openai/internal/conversation_cursor_page.rb

@@ -73,6 +73,7 @@ module OpenAI
           @data = data.map { OpenAI::Internal::Type::Converter.coerce(@model, _1) }
         else
         end
+
         @has_more = page_data[:has_more]
         @last_id = page_data[:last_id]
       end
@@ -83,8 +84,7 @@ module OpenAI
       def inspect
         model = OpenAI::Internal::Type::Converter.inspect(@model, depth: 1)
 
-        "#<#{self.class}[#{model}]:0x#{object_id.to_s(16)} " \
-          "has_more=#{has_more.inspect} last_id=#{last_id.inspect}>"
+        "#<#{self.class}[#{model}]:0x#{object_id.to_s(16)} has_more=#{has_more.inspect} last_id=#{last_id.inspect}>"
       end
     end
   end

data/lib/openai/internal/cursor_page.rb

@@ -70,6 +70,7 @@ module OpenAI
           @data = data.map { OpenAI::Internal::Type::Converter.coerce(@model, _1) }
         else
         end
+
         @has_more = page_data[:has_more]
       end