openai 0.84.0 → 0.86.0

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

@@ -133,6 +133,15 @@ module OpenAI
               index_choice_snapshot!(choice_snapshot)
             end
 
+            @current_completion_snapshot = completion_snapshot
+
+            chunk.choices.each do |choice|
+              handle_finish_reason(choice.finish_reason, completion_snapshot) if choice.finish_reason
+
+              tool_calls_by_index = @tool_call_snapshots_by_choice_index.fetch(choice.index)
+              parse_tool_calls!(choice.delta.tool_calls, tool_calls_by_index)
+            end
+
             return completion_snapshot
           end
 
@@ -144,6 +153,13 @@ module OpenAI
 
           completion_snapshot.usage = chunk.usage if chunk.usage
           completion_snapshot.system_fingerprint = chunk.system_fingerprint if chunk.system_fingerprint
+          completion_snapshot.service_tier = chunk.service_tier if chunk.service_tier
+          if chunk.moderation
+            completion_snapshot.moderation = OpenAI::Internal::Type::Converter.coerce(
+              OpenAI::Chat::ChatCompletion::Moderation,
+              model_dump(chunk.moderation)
+            )
+          end
 
           completion_snapshot
         end
@@ -172,7 +188,7 @@ module OpenAI
         def create_new_choice_snapshot(choice)
           OpenAI::Internal::Type::Converter.coerce(
             OpenAI::Models::Chat::ParsedChoice,
-            choice.to_h.except(:delta).merge(message: choice.delta.to_h)
+            choice.to_h.except(:delta).merge(message: model_dump(choice.delta))
           )
         end
 
@@ -249,7 +265,10 @@ module OpenAI
 
           choice.delta.tool_calls.each do |tool_call_delta|
             tool_call = tool_calls_by_index[tool_call_delta.index]
-            next unless tool_call&.type == :function && tool_call_delta.function
+            unless tool_call.is_a?(OpenAI::Chat::ChatCompletionMessageFunctionToolCall) &&
+                tool_call_delta.function
+              next
+            end
 
             parsed_args = if tool_call.function.respond_to?(:parsed)
               tool_call.function.parsed
@@ -310,7 +329,7 @@ module OpenAI
 
           delta_tool_calls.each do |tool_call_chunk|
             tool_call_snapshot = tool_calls_by_index[tool_call_chunk.index]
-            next unless tool_call_snapshot&.type == :function
+            next unless tool_call_snapshot.is_a?(OpenAI::Chat::ChatCompletionMessageFunctionToolCall)
 
             input_tool = find_input_tool(tool_call_snapshot.function.name)
             next unless input_tool&.dig(:function, :strict)
@@ -332,8 +351,8 @@ module OpenAI
 
           if choice_snapshot.logprobs.nil?
             choice_snapshot.logprobs = OpenAI::Chat::ChatCompletionChunk::Choice::Logprobs.new(
-              content: choice_logprobs.content,
-              refusal: choice_logprobs.refusal
+              content: choice_logprobs.content&.dup,
+              refusal: choice_logprobs.refusal&.dup
             )
           else
             if choice_logprobs.content
@@ -504,7 +523,7 @@ module OpenAI
           choices = []
           chunk.choices.each do |choice|
             choice_hash = choice.to_h
-            delta_hash = choice.delta.to_h
+            delta_hash = model_dump(choice.delta)
 
             message_data = delta_hash.dup
             message_data[:role] ||= :assistant
@@ -527,7 +546,8 @@ module OpenAI
               model: data[:model],
               choices: choices,
               usage: data[:usage],
-              system_fingerprint: nil,
+              moderation: data[:moderation],
+              system_fingerprint: data[:system_fingerprint],
               service_tier: data[:service_tier]
             }
           )
@@ -639,6 +659,8 @@ module OpenAI
           @logprobs_content_done = false
           @logprobs_refusal_done = false
           @done_tool_calls = Set.new
+          @pending_tool_calls = Set.new
+          @deferred_tool_calls = Set.new
           @current_tool_call_index = nil
         end
 
@@ -647,11 +669,6 @@ module OpenAI
 
           if choice_snapshot.finish_reason
             events.concat(content_done_events(choice_snapshot, response_format))
-
-            if @current_tool_call_index && !@done_tool_calls.include?(@current_tool_call_index)
-              event = tool_done_event(tool_calls_by_index, @current_tool_call_index)
-              events << event if event
-            end
           end
 
           Array(choice_chunk.delta.tool_calls).each do |tool_call|
@@ -659,14 +676,29 @@ module OpenAI
               events.concat(content_done_events(choice_snapshot, response_format))
 
               if @current_tool_call_index
-                event = tool_done_event(tool_calls_by_index, @current_tool_call_index)
-                events << event if event
+                if !@deferred_tool_calls.include?(@current_tool_call_index) &&
+                    incomplete_strict_tool_call?(tool_calls_by_index, @current_tool_call_index)
+                  @deferred_tool_calls.add(@current_tool_call_index)
+                end
+
+                unless @deferred_tool_calls.include?(@current_tool_call_index)
+                  event = tool_done_event(tool_calls_by_index, @current_tool_call_index)
+                  events << event if event
+                end
               end
             end
 
+            @pending_tool_calls.add(tool_call.index) unless @done_tool_calls.include?(tool_call.index)
             @current_tool_call_index = tool_call.index
           end
 
+          if choice_snapshot.finish_reason
+            @pending_tool_calls.to_a.each do |tool_index|
+              event = tool_done_event(tool_calls_by_index, tool_index)
+              events << event if event
+            end
+          end
+
           events
         end
 
@@ -730,9 +762,11 @@ module OpenAI
           return nil if @done_tool_calls.include?(tool_index)
 
           @done_tool_calls.add(tool_index)
+          @pending_tool_calls.delete(tool_index)
+          @deferred_tool_calls.delete(tool_index)
 
           tool_call = tool_calls_by_index[tool_index]
-          return nil unless tool_call&.type == :function
+          return nil unless tool_call.is_a?(OpenAI::Chat::ChatCompletionMessageFunctionToolCall)
 
           parsed_args = parse_function_tool_arguments(tool_call.function)
 
@@ -749,6 +783,22 @@ module OpenAI
           )
         end
 
+        def incomplete_strict_tool_call?(tool_calls_by_index, tool_index)
+          tool_call = tool_calls_by_index[tool_index]
+          return false unless tool_call&.type == :function
+
+          function = tool_call.function
+          tool = find_input_tool(function.name)
+          return false unless tool&.dig(:function, :strict)
+          return false unless function.respond_to?(:parsed) && function.parsed.nil?
+          return true unless function.arguments
+
+          JSON.parse(function.arguments)
+          false
+        rescue JSON::ParserError
+          true
+        end
+
         def parse_content(message, response_format)
           return nil unless response_format && message.content
 

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

@@ -22,17 +22,18 @@ module OpenAI
       #
       # Emitted as the assistant's text response is being generated. Each event
       # contains the new text fragment (delta) and the complete accumulated
-      # text so far (snapshot).
+      # text so far (snapshot). Use these string values while content is
+      # streaming; when using structured outputs, typed parsed content is
+      # available from the done event or final completion.
       #
       # @example
       #   event.delta    # => "Hello"        (new fragment)
       #   event.snapshot # => "Hello world"  (accumulated text)
-      #   event.parsed   # => {name: "John"} (if using structured outputs)
       class ChatContentDeltaEvent < OpenAI::Internal::Type::BaseModel
         required :type, const: :"content.delta"
         required :delta, String
         required :snapshot, String
-        # Partially parsed structured output
+        # Parsed content for structured outputs is available from done/final results.
         optional :parsed, Object
       end
 
@@ -81,14 +82,15 @@ module OpenAI
       # Incremental function tool call arguments update.
       #
       # Emitted as function arguments are being streamed. Provides both the
-      # raw JSON fragments and incrementally parsed arguments for strict tools.
+      # raw JSON fragments and, for strict tools, parsed arguments once the
+      # accumulated arguments are complete, valid JSON.
       #
       # @example
       #   event.name            # => "get_weather"
       #   event.index           # => 0 (tool call index in array)
-      #   event.arguments_delta # => '{"location": "San'  (new fragment)
-      #   event.arguments       # => '{"location": "San Francisco"'  (accumulated JSON)
-      #   event.parsed # => {location: "San Francisco"}  (if strict: true)
+      #   event.arguments_delta # => ' Francisco"}'  (new fragment)
+      #   event.arguments       # => '{"location": "San Francisco"}'  (accumulated JSON)
+      #   event.parsed # => {location: "San Francisco"}  (for a strict tool)
       class ChatFunctionToolCallArgumentsDeltaEvent < OpenAI::Internal::Type::BaseModel
         required :type, const: :"tool_calls.function.arguments.delta"
         required :name, String

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

@@ -19,18 +19,26 @@ module OpenAI
         end
 
         def until_done
-          each { |_event| next }
+          text.each { |_delta| nil }
           self
         end
 
         def text
           OpenAI::Internal::Util.chain_fused(@iterator) do |yielder|
+            @text_only = true
             @iterator.each do |event|
+              # Restore normal event snapshots while caller code is running.
+              @text_only = false
               case event
               when OpenAI::Models::Responses::ResponseTextDeltaEvent
                 yielder << event.delta
               end
+
+              @text_only = true
             end
+
+          ensure
+            @text_only = false
           end
         end
 
@@ -46,10 +54,11 @@ module OpenAI
           text_parts = []
 
           response.output.each do |output|
-            next unless output.type == :message
+            next unless output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
 
             output.content.each do |content|
-              next unless content.type == :output_text
+              next unless content.is_a?(OpenAI::Models::Responses::ResponseOutputText)
+
               text_parts << content.text
             end
           end
@@ -62,7 +71,7 @@ module OpenAI
         def iterator
           @iterator ||= OpenAI::Internal::Util.chain_fused(@raw_stream) do |y|
             @raw_stream.each do |raw_event|
-              events_to_yield = @state.handle_event(raw_event)
+              events_to_yield = @state.handle_event(raw_event, text_only: @text_only == true)
               events_to_yield.each do |event|
                 y << event if after_starting_event?(event)
               end
@@ -86,9 +95,10 @@ module OpenAI
           @completed_response = nil
           @text_format = text_format
           @resumed = !starting_after.nil?
+          @unexposed_buffers = {}.compare_by_identity
         end
 
-        def handle_event(event)
+        def handle_event(event, text_only: false)
           return [event] if event.is_a?(UnknownStreamEvent)
 
           @current_snapshot = accumulate_event(
@@ -100,38 +110,31 @@ module OpenAI
 
           case event
           when OpenAI::Models::Responses::ResponseTextDeltaEvent
+            return [event] if text_only
+
+            snapshot = nil
             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
-                )
-            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))
+              if output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
+                content = output.content[event.content_index]
+                snapshot = content.text if content.is_a?(OpenAI::Models::Responses::ResponseOutputText)
+              end
             end
 
+            @unexposed_buffers.delete(snapshot)
+
+            # A server-directed resumed stream or an unknown future snapshot value
+            # has no complete prefix from which to build a truthful snapshot.
+            events_to_yield <<
+              OpenAI::Streaming::ResponseTextDeltaEvent.new(event.to_h.merge(snapshot: snapshot))
+
           when OpenAI::Models::Responses::ResponseTextDoneEvent
             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.text
+              if output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
+                content = output.content[event.content_index]
+                content.text if content.is_a?(OpenAI::Models::Responses::ResponseOutputText)
+              end
             else
               event.text
             end
@@ -146,31 +149,30 @@ module OpenAI
                 sequence_number: event.sequence_number,
                 text: event.text,
                 type: event.type,
+                **event.to_h.slice(:logprobs),
                 parsed: parsed
               )
 
           when OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
+            return [event] if text_only
+
+            snapshot = nil
             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)
-                )
+              if output.is_a?(OpenAI::Models::Responses::ResponseFunctionToolCall)
+                snapshot = output.arguments
+              end
             end
 
+            @unexposed_buffers.delete(snapshot)
+
+            # See the text-delta branch above: a partial server resume or an
+            # unknown future output item has no truthful accumulated prefix.
+            events_to_yield <<
+              OpenAI::Streaming::ResponseFunctionCallArgumentsDeltaEvent.new(
+                event.to_h.merge(snapshot: snapshot)
+              )
+
           when OpenAI::Models::Responses::ResponseCompletedEvent
             events_to_yield <<
               OpenAI::Streaming::ResponseCompletedEvent.new(
@@ -190,12 +192,7 @@ module OpenAI
         def accumulate_event(event:, current_snapshot:)
           if current_snapshot.nil?
             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
-              )
+              return isolated_value(event.response)
             end
 
             unless @resumed
@@ -212,21 +209,21 @@ module OpenAI
 
           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)
+            if output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
+              output.content.push(isolated_value(event.part))
               current_snapshot.output[event.output_index] = output
             end
 
           when OpenAI::Models::Responses::ResponseTextDeltaEvent
             output = current_snapshot.output[event.output_index]
-            if output && output.type == :message
+            if output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
               content = output.content[event.content_index]
-              if content && content.type == :output_text
-                content.text += event.delta
+              if content.is_a?(OpenAI::Models::Responses::ResponseOutputText)
+                content.text = append_delta(content.text, event.delta)
                 output.content[event.content_index] = content
                 current_snapshot.output[event.output_index] = output
               end
@@ -234,8 +231,8 @@ module OpenAI
 
           when OpenAI::Models::Responses::ResponseFunctionCallArgumentsDeltaEvent
             output = current_snapshot.output[event.output_index]
-            if output && output.type == :function_call
-              output.arguments = (output.arguments || "") + event.delta
+            if output.is_a?(OpenAI::Models::Responses::ResponseFunctionToolCall)
+              output.arguments = append_delta(output.arguments || "", event.delta)
               current_snapshot.output[event.output_index] = output
             end
 
@@ -248,10 +245,24 @@ module OpenAI
 
         private
 
-        def assert_type(object, expected_type)
-          return if object && object.type == expected_type
-          actual_type = object ? object.type : "nil"
-          raise "Invalid state: expected #{expected_type} but got #{actual_type}"
+        # Reuse a buffer only until it becomes a caller-visible snapshot. The
+        # first append also isolates strings belonging to incoming wire events.
+        def append_delta(value, delta)
+          return value << delta if @unexposed_buffers.key?(value)
+
+          buffer = value + delta
+          @unexposed_buffers[buffer] = true
+          buffer
+        end
+
+        # 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 parse_structured_text(text)
@@ -260,10 +271,10 @@ module OpenAI
           begin
             parsed = JSON.parse(text, symbolize_names: true)
             OpenAI::Internal::Type::Converter.coerce(@text_format, parsed)
-          rescue JSON::ParserError => e
+          rescue JSON::ParserError
             raise(
-              "Failed to parse structured text as JSON for #{@text_format}: #{e.message}. " \
-                "Raw text: #{text.inspect}"
+              "Failed to parse structured text as JSON for #{@text_format}",
+              cause: nil
             )
           end
         end

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

@@ -67,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: {
@@ -78,7 +81,7 @@ module OpenAI
             )
           in {
               response_format: {
-                  type: :json_schema,
+                  type: :json_schema | "json_schema",
                   json_schema: {schema: OpenAI::StructuredOutput::JsonSchemaConverter => model}
                 }
             }
@@ -124,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,7 +105,11 @@ module OpenAI
             defs, path = state.fetch_values(:defs, :path)
             if (stored = defs[type])
               pointers = stored.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS)
-              pointers.first.except(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF).tap do
+              if pointers.first.fetch(:$ref).empty?
+                stored[OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::RECURSIVE] = true
+              end
+
+              pointers.first.slice(:$ref).tap do
                 pointers << _1
               end
             else
@@ -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