openai 0.83.0 → 0.85.0

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,26 +189,30 @@ 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)
+              return isolated_value(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
           when OpenAI::Models::Responses::ResponseOutputItemAddedEvent
-            current_snapshot.output.push(event.item)
+            current_snapshot.output.push(isolated_value(event.item))
 
           when OpenAI::Models::Responses::ResponseContentPartAddedEvent
             output = current_snapshot.output[event.output_index]
             if output && output.type == :message
-              output.content.push(event.part)
+              output.content.push(isolated_value(event.part))
               current_snapshot.output[event.output_index] = output
             end
 
@@ -217,6 +243,16 @@ module OpenAI
 
         private
 
+        # Materialize fresh containers before snapshot accumulation mutates them.
+        # Coercing an already-typed model returns it unchanged, so first use the
+        # model's recursive raw representation. Unknown union fallbacks stay raw.
+        def isolated_value(value)
+          raw = OpenAI::Internal::Type::BaseModel.recursively_to_h(value, convert: false)
+          return raw unless value.is_a?(OpenAI::Internal::Type::BaseModel)
+
+          OpenAI::Internal::Type::Converter.coerce(value.class, raw)
+        end
+
         def assert_type(object, expected_type)
           return if object && object.type == expected_type
           actual_type = object ? object.type : "nil"

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

@@ -24,10 +24,10 @@ module OpenAI
         # @return [Hash{Symbol=>Object}]
         def to_json_schema_inner(state:)
           OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.cache_def!(state, type: self) do
-            state.fetch(:path) << "[]"
+            new_state = {**state, path: [*state.fetch(:path), "[]"]}
             items = OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_json_schema_inner(
               item_type,
-              state: state
+              state: new_state
             )
             items = OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_nilable(items) if nilable?
             OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.assoc_meta!(items, meta: @meta)

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

@@ -32,13 +32,27 @@ module OpenAI
             OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.cache_def!(state, type: self) do
               path = state.fetch(:path)
               properties = field_values.to_h do |field|
-                api_name, type, nilable, meta = field.fetch_values(:api_name, :type, :nilable, :meta)
+                api_name, type, nilable, const, meta = field.fetch_values(:api_name, :type, :nilable, :const, :meta)
                 new_state = {**state, path: [*path, ".#{api_name}"]}
 
-                schema = OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_json_schema_inner(
-                  type,
-                  state: new_state
-                )
+                literal_const = case const
+                when Integer, TrueClass, FalseClass
+                  true
+                when Float
+                  const.finite?
+                else
+                  false
+                end
+
+                schema = if literal_const
+                  {const: const}
+                else
+                  OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_json_schema_inner(
+                    type,
+                    state: new_state
+                  )
+                end
+
                 schema = OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.to_nilable(schema) if nilable
                 OpenAI::Helpers::StructuredOutput::JsonSchemaConverter.assoc_meta!(
                   schema,

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?
 
@@ -65,7 +67,10 @@ module OpenAI
               }
             )
           in {
-              response_format: {type: :json_schema, json_schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}
+              response_format: {
+                  type: :json_schema | "json_schema",
+                  json_schema: OpenAI::StructuredOutput::JsonSchemaConverter => model
+                }
             }
             parsed.fetch(:response_format).update(
               json_schema: {
@@ -76,11 +81,15 @@ module OpenAI
             )
           in {
               response_format: {
-                  type: :json_schema,
+                  type: :json_schema | "json_schema",
                   json_schema: {schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}
                 }
             }
             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
@@ -118,7 +127,7 @@ module OpenAI
           return [] if tools.nil?
 
           tools.map do |tool|
-            next tool unless tool[:type] == :function
+            next tool unless [:function, "function"].include?(tool[:type])
 
             function_name = tool.dig(:function, :name)
             model = tool_models[function_name]

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

@@ -23,6 +23,15 @@ module OpenAI
             end
           end
           .freeze
+        # @api private
+        RECURSIVE = Object
+          .new
+          .tap do
+            _1.define_singleton_method(:inspect) do
+              "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::RECURSIVE>"
+            end
+          end
+          .freeze
 
         # rubocop:disable Lint/UnusedMethodArgument
 
@@ -56,6 +65,8 @@ module OpenAI
                   {type: null}
                 ]
               }
+            in {const: _}
+              {anyOf: [schema, {type: null}]}
             in {anyOf: schemas}
               null = {type: null}
               schemas.any? { _1 == null || _1 == {type: ["null"]} } ? schema : {anyOf: [*schemas, null]}
@@ -94,6 +105,10 @@ module OpenAI
             defs, path = state.fetch_values(:defs, :path)
             if (stored = defs[type])
               pointers = stored.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS)
+              if pointers.first.fetch(:$ref).empty?
+                stored[OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::RECURSIVE] = true
+              end
+
               pointers.first.except(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF).tap do
                 pointers << _1
               end
@@ -128,27 +143,35 @@ module OpenAI
             )
             reused_defs = {}
             defs.each_value do |acc|
-              sch = acc.except(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS)
+              recursive = acc.key?(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::RECURSIVE)
+              sch = acc.except(
+                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS,
+                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::RECURSIVE
+              )
               pointers = acc.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS)
 
               no_refs, refs = pointers.partition do
                 _1.delete(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF)
               end
 
-              case refs
-              in [ref]
-                ref.replace(ref.except(:$ref).merge(sch))
-              in [_, ref, *]
-                reused_defs.store(ref.fetch(:$ref), sch)
-                refs.each do
-                  unless (meta = _1.except(:$ref)).empty?
-                    _1.replace(allOf: [_1.slice(:$ref), meta])
+              if recursive
+                reused_defs.store(pointers.first.fetch(:$ref), sch)
+              else
+                case refs
+                in [ref]
+                  ref.replace(ref.except(:$ref).merge(sch))
+                in [_, ref, *]
+                  reused_defs.store(ref.fetch(:$ref), sch)
+                  refs.each do
+                    unless (meta = _1.except(:$ref)).empty?
+                      _1.replace(allOf: [_1.slice(:$ref), meta])
+                    end
                   end
+                else
                 end
-              else
               end
 
-              no_refs.each { _1.replace(_1.except(:$ref).merge(sch)) }
+              no_refs.each { _1.replace(_1.except(:$ref).merge(sch)) } unless recursive
             end
 
             xformed = reused_defs.transform_keys do

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/internal/type/base_model.rb

@@ -119,7 +119,7 @@ module OpenAI
                 Kernel.then do
                   value = @data.fetch(name_sym) { const == OpenAI::Internal::OMIT ? nil : const }
                   state = OpenAI::Internal::Type::Converter.new_coerce_state(translate_names: false)
-                  if (nilable || !required) && value.nil?
+                  if (nilable || !required) && nil.equal?(value)
                     nil
                   else
                     OpenAI::Internal::Type::Converter.coerce(
@@ -321,7 +321,7 @@ module OpenAI
               keys.delete(src_name)
 
               state[:error] = nil
-              converted = if item.nil? && (nilable || !required)
+              converted = if nil.equal?(item) && (nilable || !required)
                 exactness[nilable ? :yes : :maybe] += 1
                 nil
               else

data/lib/openai/internal/type/converter.rb

@@ -199,7 +199,7 @@ module OpenAI
 
               case target
               in -> { _1 <= NilClass }
-                exactness[value.nil? ? :yes : :maybe] += 1
+                exactness[nil.equal?(value) ? :yes : :maybe] += 1
                 return nil
               in -> { _1 <= Integer }
                 case value

data/lib/openai/internal/util.rb

@@ -510,7 +510,7 @@ module OpenAI
             IO.copy_stream(val, y)
           in StringIO
             y << format(content_line, content_type || "application/octet-stream")
-            y << val.string
+            y << (val.string.byteslice(val.pos..) || "")
           in -> { primitive?(_1) }
             y << format(content_line, content_type || "text/plain")
             y << val.to_s
@@ -630,7 +630,7 @@ module OpenAI
           in [OpenAI::Internal::Util::JSON_CONTENT, Hash | Array | -> { primitive?(_1) }]
             [headers, JSON.generate(body)]
           in [OpenAI::Internal::Util::JSONL_CONTENT, Enumerable] unless OpenAI::Internal::Type::FileInput === body
-            [headers, body.lazy.map { JSON.generate(_1) }]
+            [headers, body.lazy.map { "#{JSON.generate(_1)}\n" }]
           in [%r{^multipart/form-data}, Hash | OpenAI::Internal::Type::FileInput]
             boundary, strio = encode_multipart_streaming(body)
             headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"}

data/lib/openai/internal/vector_store_file_uploader.rb

@@ -132,7 +132,7 @@ module OpenAI
         complete = false
         case content
         in StringIO
-          temporary_file.write(content.string)
+          temporary_file.write(content.string.byteslice(content.pos..) || "")
         in String
           temporary_file.write(content)
         in IO

data/lib/openai/models/admin/organization/usage_costs_params.rb

@@ -51,6 +51,13 @@ module OpenAI
           #   @return [Integer, nil]
           optional :limit, Integer
 
+          # @!attribute line_items
+          #   Return only costs for these exact line item names. Each value must match the
+          #   complete `line_item` value, for example `gpt-6-astra, input_tokens`.
+          #
+          #   @return [Array<String>, nil]
+          optional :line_items, OpenAI::Internal::Type::ArrayOf[String]
+
           # @!attribute page
           #   A cursor for use in pagination. Corresponding to the `next_page` field from the
           #   previous response.
@@ -64,7 +71,7 @@ module OpenAI
           #   @return [Array<String>, nil]
           optional :project_ids, OpenAI::Internal::Type::ArrayOf[String]
 
-          # @!method initialize(start_time:, api_key_ids: nil, bucket_width: nil, end_time: nil, group_by: nil, limit: nil, page: nil, project_ids: nil, request_options: {})
+          # @!method initialize(start_time:, api_key_ids: nil, bucket_width: nil, end_time: nil, group_by: nil, limit: nil, line_items: nil, page: nil, project_ids: nil, request_options: {})
           #   Some parameter documentations has been truncated, see
           #   {OpenAI::Models::Admin::Organization::UsageCostsParams} for more details.
           #
@@ -80,6 +87,8 @@ module OpenAI
           #
           #   @param limit [Integer] A limit on the number of buckets to be returned. Limit can range between 1 and 1
           #
+          #   @param line_items [Array<String>] Return only costs for these exact line item names. Each value must match the com
+          #
           #   @param page [String] A cursor for use in pagination. Corresponding to the `next_page` field from the
           #
           #   @param project_ids [Array<String>] Return only costs for these projects.

data/lib/openai/models/batch.rb

@@ -116,9 +116,9 @@ module OpenAI
       optional :metadata, OpenAI::Internal::Type::HashOf[String], nil?: true
 
       # @!attribute model
-      #   Model ID used to process the batch, like `gpt-5-2025-08-07`. OpenAI offers a
-      #   wide range of models with different capabilities, performance characteristics,
-      #   and price points. Refer to the
+      #   Model ID used to process the batch, like `gpt-6-astra`. OpenAI offers a wide
+      #   range of models with different capabilities, performance characteristics, and
+      #   price points. Refer to the
       #   [model guide](https://platform.openai.com/docs/models) to browse and compare
       #   available models.
       #
@@ -183,7 +183,7 @@ module OpenAI
       #
       #   @param metadata [Hash{Symbol=>String}, nil] Set of 16 key-value pairs that can be attached to an object. This can be
       #
-      #   @param model [String] Model ID used to process the batch, like `gpt-5-2025-08-07`. OpenAI
+      #   @param model [String] Model ID used to process the batch, like `gpt-6-astra`. OpenAI
       #
       #   @param output_file_id [String] The ID of the file containing the outputs of successfully executed requests.
       #

data/lib/openai/models/beta/beta_custom_tool.rb

@@ -26,6 +26,13 @@ module OpenAI
           nil?: true
         )
 
+        # @!attribute async
+        #   Whether the tool response can be returned asynchronously versus immediately
+        #   returned on next response creation.
+        #
+        #   @return [Boolean, nil]
+        optional :async, OpenAI::Internal::Type::Boolean
+
         # @!attribute defer_loading
         #   Whether this tool should be deferred and discovered via tool search.
         #
@@ -44,7 +51,10 @@ module OpenAI
         #   @return [OpenAI::Models::Beta::BetaCustomTool::Format::Text, OpenAI::Models::Beta::BetaCustomTool::Format::Grammar, nil]
         optional :format_, union: -> { OpenAI::Beta::BetaCustomTool::Format }, api_name: :format
 
-        # @!method initialize(name:, allowed_callers: nil, defer_loading: nil, description: nil, format_: nil, type: :custom)
+        # @!method initialize(name:, allowed_callers: nil, async: nil, defer_loading: nil, description: nil, format_: nil, type: :custom)
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Beta::BetaCustomTool} for more details.
+        #
         #   A custom tool that processes input using a specified format. Learn more about
         #   [custom tools](https://platform.openai.com/docs/guides/function-calling#custom-tools)
         #
@@ -52,6 +62,8 @@ module OpenAI
         #
         #   @param allowed_callers [Array<Symbol, OpenAI::Models::Beta::BetaCustomTool::AllowedCaller>, nil] The tool invocation context(s).
         #
+        #   @param async [Boolean] Whether the tool response can be returned asynchronously versus immediately retu
+        #
         #   @param defer_loading [Boolean] Whether this tool should be deferred and discovered via tool search.
         #
         #   @param description [String] Optional description of the custom tool, used to provide more context.

data/lib/openai/models/beta/beta_function_tool.rb

@@ -38,6 +38,11 @@ module OpenAI
           nil?: true
         )
 
+        # @!attribute async
+        #
+        #   @return [Boolean, nil]
+        optional :async, OpenAI::Internal::Type::Boolean
+
         # @!attribute defer_loading
         #   Whether this function is deferred and loaded via tool search.
         #
@@ -58,7 +63,7 @@ module OpenAI
         #   @return [Hash{Symbol=>Object}, nil]
         optional :output_schema, OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown], nil?: true
 
-        # @!method initialize(name:, parameters:, strict:, allowed_callers: nil, defer_loading: nil, description: nil, output_schema: nil, type: :function)
+        # @!method initialize(name:, parameters:, strict:, allowed_callers: nil, async: nil, defer_loading: nil, description: nil, output_schema: nil, type: :function)
         #   Some parameter documentations has been truncated, see
         #   {OpenAI::Models::Beta::BetaFunctionTool} for more details.
         #
@@ -74,6 +79,8 @@ module OpenAI
         #
         #   @param allowed_callers [Array<Symbol, OpenAI::Models::Beta::BetaFunctionTool::AllowedCaller>, nil] The tool invocation context(s).
         #
+        #   @param async [Boolean]
+        #
         #   @param defer_loading [Boolean] Whether this function is deferred and loaded via tool search.
         #
         #   @param description [String, nil] A description of the function. Used by the model to determine whether or not to

data/lib/openai/models/beta/beta_namespace_tool.rb

@@ -73,6 +73,13 @@ module OpenAI
               nil?: true
             )
 
+            # @!attribute async
+            #   Whether the tool response can be returned asynchronously versus immediately
+            #   returned on next response creation.
+            #
+            #   @return [Boolean, nil]
+            optional :async, OpenAI::Internal::Type::Boolean
+
             # @!attribute defer_loading
             #   Whether this function should be deferred and discovered via tool search.
             #
@@ -108,7 +115,7 @@ module OpenAI
             #   @return [Boolean, nil]
             optional :strict, OpenAI::Internal::Type::Boolean, nil?: true
 
-            # @!method initialize(name:, allowed_callers: nil, defer_loading: nil, description: nil, output_schema: nil, parameters: nil, strict: nil, type: :function)
+            # @!method initialize(name:, allowed_callers: nil, async: nil, defer_loading: nil, description: nil, output_schema: nil, parameters: nil, strict: nil, type: :function)
             #   Some parameter documentations has been truncated, see
             #   {OpenAI::Models::Beta::BetaNamespaceTool::Tool::Function} for more details.
             #
@@ -116,6 +123,8 @@ module OpenAI
             #
             #   @param allowed_callers [Array<Symbol, OpenAI::Models::Beta::BetaNamespaceTool::Tool::Function::AllowedCaller>, nil] The tool invocation context(s).
             #
+            #   @param async [Boolean] Whether the tool response can be returned asynchronously versus immediately retu
+            #
             #   @param defer_loading [Boolean] Whether this function should be deferred and discovered via tool search.
             #
             #   @param description [String, nil]