llm_gateway 0.6.0 → 0.7.0

data/lib/llm_gateway/adapters/groq/option_mapper.rb

@@ -68,7 +68,7 @@ module LlmGateway
         module_function
 
         def map(options)
-          mapped_options = options.reject { |key, _| MANAGED_OPTIONS.include?(key) }
+          mapped_options = options.except(*MANAGED_OPTIONS)
           mapped_options[:temperature] = options.key?(:temperature) ? options[:temperature] : DEFAULT_TEMPERATURE
           mapped_options[:max_completion_tokens] = options[:max_completion_tokens] || DEFAULT_MAX_COMPLETION_TOKENS
           mapped_options[:response_format] = normalize_response_format(options[:response_format] || "text")

data/lib/llm_gateway/adapters/input_message_sanitizer.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require "json"
+
 module LlmGateway
   module Adapters
     class InputMessageSanitizer
       def self.sanitize(messages, target_provider:, target_api:, target_model:)
         return messages unless messages.is_a?(Array)
 
-        messages.map do |message|
+        sanitized = messages.map do |message|
           sanitize_message(
             message,
             target_provider: target_provider,
@@ -14,6 +16,8 @@ module LlmGateway
             target_model: target_model
           )
         end
+
+        relocate_assistant_tool_results(sanitized)
       end
 
       def self.sanitize_message(message, target_provider:, target_api:, target_model:)
@@ -25,9 +29,14 @@ module LlmGateway
         return message unless message_metadata_present?(message)
 
         same_model_replay = same_model_replay?(message, target_provider:, target_api:, target_model:)
+        same_provider_api_replay = same_provider_api_replay?(message, target_provider:, target_api:)
 
         sanitized_content = content.each_with_object([]) do |block, acc|
-          sanitized = sanitize_content_block(block, same_model_replay: same_model_replay)
+          sanitized = sanitize_content_block(
+            block,
+            same_model_replay: same_model_replay,
+            same_provider_api_replay: same_provider_api_replay
+          )
           next if sanitized.nil?
 
           if sanitized.is_a?(Array)
@@ -40,19 +49,91 @@ module LlmGateway
         message.merge(content: sanitized_content)
       end
 
-      def self.sanitize_content_block(block, same_model_replay:)
+      def self.sanitize_content_block(block, same_model_replay:, same_provider_api_replay:)
         return block unless block.is_a?(Hash)
 
         type = block[:type] || block["type"]
+
+        if type == "server_tool_use"
+          return normalize_server_tool_use_for_replay(block) if same_provider_api_replay
+
+          return convert_server_tool_use_to_tool_use(block)
+        end
+
+        if type == "server_tool_result"
+          return block if same_provider_api_replay
+
+          return convert_server_tool_result_to_tool_result(block)
+        end
+
         return block unless %w[thinking reasoning].include?(type)
         return block if same_model_replay
 
         text = extract_reasoning_text(block)
-        return nil if text.nil? || text.strip.empty?
+        return nil if text.blank?
 
         { type: "text", text: text }
       end
 
+      def self.normalize_server_tool_use_for_replay(block)
+        input = block[:input] || block["input"]
+        return block unless input.is_a?(Hash)
+
+        outputs = input[:outputs] || input["outputs"]
+        return block unless outputs.is_a?(Hash)
+
+        normalized_input = input.merge(outputs: outputs.values)
+        normalized_input.delete(:outputs) if input.key?("outputs") && !input.key?(:outputs)
+        normalized_input["outputs"] = outputs.values if input.key?("outputs")
+
+        normalized = block.merge(input: normalized_input)
+        normalized.delete(:input) if block.key?("input") && !block.key?(:input)
+        normalized["input"] = normalized_input if block.key?("input")
+        normalized
+      end
+
+      def self.convert_server_tool_use_to_tool_use(block)
+        converted = block.merge(type: "tool_use")
+        converted.delete(:type) if block.key?("type") && !block.key?(:type)
+        converted["type"] = "tool_use" if block.key?("type")
+        converted
+      end
+
+      def self.convert_server_tool_result_to_tool_result(block)
+        converted = block.merge(type: "tool_result")
+        converted.delete(:type) if block.key?("type") && !block.key?(:type)
+        converted["type"] = "tool_result" if block.key?("type")
+
+        content = converted[:content] || converted["content"]
+        if content.is_a?(Hash)
+          converted = converted.merge(content: JSON.generate(content))
+          converted.delete(:content) if block.key?("content") && !block.key?(:content)
+          converted["content"] = JSON.generate(content) if block.key?("content")
+        end
+
+        converted
+      end
+
+      def self.relocate_assistant_tool_results(messages)
+        messages.flat_map do |message|
+          next message unless message.is_a?(Hash)
+
+          role = message[:role] || message["role"]
+          content = message[:content] || message["content"]
+          next message unless role == "assistant" && content.is_a?(Array)
+
+          tool_results, assistant_content = content.partition do |block|
+            block.is_a?(Hash) && (block[:type] || block["type"]) == "tool_result"
+          end
+          next message if tool_results.empty?
+
+          relocated = []
+          relocated << message.merge(content: assistant_content) unless assistant_content.empty?
+          relocated << { role: "user", content: tool_results }
+          relocated
+        end
+      end
+
       def self.extract_reasoning_text(block)
         return block[:thinking] if block[:thinking].is_a?(String)
         return block[:reasoning] if block[:reasoning].is_a?(String)
@@ -65,7 +146,7 @@ module LlmGateway
 
             item[:text] || item[:summary_text] || item[:reasoning]
           end.join("\n")
-          return text unless text.empty?
+          return text if text.present?
         end
 
         nil
@@ -79,15 +160,25 @@ module LlmGateway
         provider == target_provider && api == target_api && model == target_model
       end
 
+      def self.same_provider_api_replay?(message, target_provider:, target_api:)
+        provider = message[:provider] || message["provider"]
+        api = message[:api] || message["api"]
+
+        provider == target_provider && api == target_api
+      end
+
       def self.message_metadata_present?(message)
         provider = message[:provider] || message["provider"]
         api = message[:api] || message["api"]
         model = message[:model] || message["model"]
 
-        !provider.nil? && !api.nil? && !model.nil?
+        provider.present? && api.present? && model.present?
       end
 
-      private_class_method :sanitize_message, :sanitize_content_block, :extract_reasoning_text, :same_model_replay?, :message_metadata_present?
+      private_class_method :sanitize_message, :sanitize_content_block, :normalize_server_tool_use_for_replay,
+        :convert_server_tool_use_to_tool_use, :convert_server_tool_result_to_tool_result,
+        :relocate_assistant_tool_results, :extract_reasoning_text, :same_model_replay?,
+        :same_provider_api_replay?, :message_metadata_present?
     end
   end
 end

data/lib/llm_gateway/adapters/normalized_stream_accumulator.rb

@@ -34,10 +34,14 @@ module LlmGateway
       #   { type: :reasoning_delta, delta: "...", signature: "" }
       #   { type: :reasoning_end, delta: "", signature: "" }
       #
-      #   { type: :tool_start, id: "...", name: "tool_name", delta: "" }
+      #   { type: :tool_start, id: "...", name: "tool_name", tool_type: "tool_use", delta: "" }
       #   { type: :tool_delta, delta: "{\"a\":" }
       #   { type: :tool_end, delta: "" }
       #
+      #   { type: :tool_result_start, tool_use_id: "...", name: "server_tool_result", delta: "..." }
+      #   { type: :tool_result_delta, delta: "..." }
+      #   { type: :tool_result_end, delta: "" }
+      #
       # Mappers do not provide `content_index`. The accumulator assigns the next
       # public content index when a block starts and reuses the active content
       # index for that block's deltas and end event.
@@ -68,6 +72,9 @@ module LlmGateway
         tool_start: { block_type: :tool, phase: :start },
         tool_delta: { block_type: :tool, phase: :delta },
         tool_end: { block_type: :tool, phase: :end },
+        tool_result_start: { block_type: :tool_result, phase: :start },
+        tool_result_delta: { block_type: :tool_result, phase: :delta },
+        tool_result_end: { block_type: :tool_result, phase: :end },
         reasoning_start: { block_type: :reasoning, phase: :start },
         reasoning_delta: { block_type: :reasoning, phase: :delta },
         reasoning_end: { block_type: :reasoning, phase: :end }
@@ -106,7 +113,7 @@ module LlmGateway
       def push(event_patch, &block)
         raise ArgumentError, "Normalized stream event patch must be a Hash" unless event_patch.is_a?(Hash)
 
-        event_patch = symbolize_keys(event_patch)
+        event_patch = event_patch.symbolize_keys
         type = event_patch.fetch(:type).to_sym
         event_patch = prepare_event_patch(event_patch.merge(type:), type)
         ensure_timestamp!
@@ -188,12 +195,12 @@ module LlmGateway
       end
 
       def build_event(event_patch, partial:)
-        event_patch = symbolize_keys(event_patch)
+        event_patch = event_patch.symbolize_keys
         type = event_patch.fetch(:type).to_sym
 
         case type
         when :message_start, :message_delta
-          delta = symbolize_keys(event_patch[:delta] || {})
+          delta = (event_patch[:delta] || {}).symbolize_keys
           raw_usage = event_patch[:usage] || delta.delete(:usage) || {}
           usage = raw_usage.empty? ? {} : normalized_usage(raw_usage)
 
@@ -210,6 +217,16 @@ module LlmGateway
             delta: string_value(event_patch[:delta]),
             id: event_patch[:id],
             name: event_patch[:name],
+            partial:,
+            tool_type: event_patch[:tool_type] || "tool_use"
+          )
+        when :tool_result_start
+          AssistantToolResultStartEvent.new(
+            type:,
+            content_index: event_patch.fetch(:content_index),
+            delta: string_value(event_patch[:delta]),
+            tool_use_id: event_patch[:tool_use_id],
+            name: event_patch[:name],
             partial:
           )
         when :reasoning_start, :reasoning_delta, :reasoning_end
@@ -220,7 +237,7 @@ module LlmGateway
             signature: string_value(event_patch[:signature]),
             partial:
           )
-        when :text_start, :text_delta, :text_end, :tool_delta, :tool_end
+        when :text_start, :text_delta, :text_end, :tool_delta, :tool_end, :tool_result_delta, :tool_result_end
           AssistantStreamEvent.new(
             type:,
             content_index: event_patch.fetch(:content_index),
@@ -246,13 +263,21 @@ module LlmGateway
           blocks[event.content_index][:text] += event.delta
         when :tool_start
           blocks[event.content_index] = {
-            type: "tool_use",
+            type: event.tool_type,
             id: event.id,
             name: event.name,
             input: event.delta.to_s
           }
         when :tool_delta, :tool_end
           blocks[event.content_index][:input] += event.delta
+        when :tool_result_start
+          blocks[event.content_index] = {
+            type: event.name,
+            tool_use_id: event.tool_use_id,
+            content: event.delta.to_s
+          }
+        when :tool_result_delta, :tool_result_end
+          blocks[event.content_index][:content] += event.delta
         when :message_start
           message_hash.merge!(event.delta)
         when :reasoning_start
@@ -294,7 +319,7 @@ module LlmGateway
       end
 
       def normalized_usage(usage)
-        usage = default_usage.merge(symbolize_keys(usage).slice(*DEFAULT_USAGE.keys))
+        usage = default_usage.merge(usage.to_h.symbolize_keys.slice(*DEFAULT_USAGE.keys))
         usage[:total] = usage[:input] + usage[:cache_write] + usage[:cache_read] + usage[:output]
         usage[:raw] ||= {}
         usage
@@ -305,25 +330,32 @@ module LlmGateway
       end
 
       def serialized_blocks
-        blocks.map do |content_block|
-          next content_block unless content_block[:type] == "tool_use"
-
-          content_block.merge(input: LlmGateway::Utils.deep_symbolize_keys(parse_tool_input(content_block[:input])))
+        blocks.compact.map do |content_block|
+          if [ "tool_use", "server_tool_use" ].include?(content_block[:type])
+            next content_block.merge(input: parse_tool_input(content_block[:input]).deep_symbolize_keys)
+          end
+
+          if content_block[:type]&.end_with?("_tool_result")
+            next {
+              type: "server_tool_result",
+              tool_use_id: content_block[:tool_use_id],
+              name: content_block[:type],
+              content: parse_tool_input(content_block[:content]).deep_symbolize_keys
+            }
+          end
+
+          content_block
         end
       end
 
       def parse_tool_input(input)
-        return {} if input.nil? || input.empty?
+        return {} if input.blank?
 
         JSON.parse(input)
       rescue JSON::ParserError
         {}
       end
 
-      def symbolize_keys(hash)
-        hash.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
-      end
-
       def string_value(value)
         value.nil? ? "" : value.to_s
       end

data/lib/llm_gateway/adapters/openai/chat_completions/option_mapper.rb

@@ -66,7 +66,7 @@ module LlmGateway
           module_function
 
           def map(options)
-            mapped_options = options.reject { |key, _| MANAGED_OPTIONS.include?(key) }
+            mapped_options = options.except(*MANAGED_OPTIONS)
             mapped_options[:max_completion_tokens] = options[:max_completion_tokens] || DEFAULT_MAX_COMPLETION_TOKENS
 
             cache_key = options[:cache_key]

data/lib/llm_gateway/adapters/openai/responses/input_mapper.rb

@@ -37,22 +37,28 @@ module LlmGateway
               return tools unless tools
 
               tools.map do |tool|
-                mapped_tool = {
-                  type: "function",
-                  name: tool[:name],
-                  description: tool[:description],
-                  parameters: tool[:input_schema]
-                }
-
-                [ :contents, :content ].each do |key|
-                  next unless tool[key].is_a?(Array)
-
-                  mapped_tool[key] = tool[key].map do |entry|
-                    entry.is_a?(Hash) ? map_content(entry.transform_keys(&:to_sym)) : entry
+                tool = tool.transform_keys(&:to_sym)
+
+                if tool[:name].nil?
+                  tool
+                else
+                  mapped_tool = {
+                    type: "function",
+                    name: tool[:name],
+                    description: tool[:description],
+                    parameters: tool[:input_schema]
+                  }
+
+                  [ :contents, :content ].each do |key|
+                    next unless tool[key].is_a?(Array)
+
+                    mapped_tool[key] = tool[key].map do |entry|
+                      entry.is_a?(Hash) ? map_content(entry.transform_keys(&:to_sym)) : entry
+                    end
                   end
-                end
 
-                mapped_tool
+                  mapped_tool
+                end
               end
             end
 
@@ -85,30 +91,40 @@ module LlmGateway
             def map_assistant_history_message(msg)
               blocks = (msg[:content] || []).map { |b| b.transform_keys(&:to_sym) }
 
-              text_blocks = blocks.select { |b| b[:type] == "text" }
-              tool_use_blocks = blocks.select { |b| b[:type] == "tool_use" }
-
               result = []
 
-              if text_blocks.any?
-                result << {
-                  role: "assistant",
-                  content: text_blocks.map { |b| { type: "output_text", text: b[:text] } }
-                }
-              end
-
-              tool_use_blocks.each do |b|
-                result << {
-                  type: "function_call",
-                  call_id: b[:id],
-                  name: b[:name],
-                  arguments: b[:input].is_a?(Hash) ? b[:input].to_json : (b[:input] || {}).to_json
-                }
+              blocks.each do |block|
+                case block[:type]
+                when "text"
+                  result << {
+                    role: "assistant",
+                    content: [ { type: "output_text", text: block[:text] } ]
+                  }
+                when "tool_use"
+                  result << {
+                    type: "function_call",
+                    call_id: block[:id],
+                    name: block[:name],
+                    arguments: block[:input].is_a?(Hash) ? block[:input].to_json : (block[:input] || {}).to_json
+                  }
+                when "server_tool_use"
+                  result << map_server_tool_use_history_item(block)
+                end
               end
 
               result
             end
 
+            def map_server_tool_use_history_item(block)
+              input = block[:input].is_a?(Hash) ? block[:input] : {}
+
+              {
+                id: block[:id],
+                type: block[:name],
+                status: "completed"
+              }.merge(input)
+            end
+
             def map_messages_content(message)
               message[:content].map { |content| map_content(content) }
             end

data/lib/llm_gateway/adapters/openai/responses/option_mapper.rb

@@ -58,7 +58,7 @@ module LlmGateway
           module_function
 
           def map(options)
-            mapped_options = options.reject { |key, _| MANAGED_OPTIONS.include?(key) }
+            mapped_options = options.except(*MANAGED_OPTIONS)
             mapped_options[:max_output_tokens] = options[:max_completion_tokens] || options[:max_output_tokens] || DEFAULT_MAX_OUTPUT_TOKENS
 
             cache_key = options[:cache_key]

data/lib/llm_gateway/adapters/openai/responses/stream_mapper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 require_relative "../../stream_mapper"
 
 module LlmGateway
@@ -23,10 +25,16 @@ module LlmGateway
               response_created_patches(data[:response])
             when "response.output_item.added"
               output_item_added_patches(data)
+            when "response.output_item.done"
+              output_item_done_patches(data)
             when "response.content_part.added"
               content_part_added_patches(data)
-            when "response.content_part.done"
+            when "response.content_part.done", "response.output_text.done"
               content_part_done_patches(data)
+            when "response.code_interpreter_call_code.delta"
+              code_interpreter_code_delta_patches(data)
+            when "response.code_interpreter_call.in_progress", "response.code_interpreter_call.interpreting", "response.code_interpreter_call.completed", "response.code_interpreter_call_code.done"
+              []
             when "response.output_text.delta"
               [ { type: :text_delta, delta: data[:delta] || "" } ]
             when "response.function_call_arguments.delta"
@@ -84,6 +92,38 @@ module LlmGateway
                   name: item[:name]
                 }
               ]
+            when "code_interpreter_call"
+              state = code_interpreter_state[data[:output_index] || 0] = {
+                id: item[:id],
+                container_id: item[:container_id],
+                outputs: item[:outputs],
+                input_opened: false,
+                input_closed: false
+              }
+              container_id_to_tool_id[state[:container_id]] = state[:id] if state[:container_id]
+
+              [
+                {
+                  type: :tool_start,
+                  delta: "",
+                  id: item[:id],
+                  name: "code_interpreter_call",
+                  tool_type: "server_tool_use"
+                }
+              ]
+            else
+              []
+            end
+          end
+
+          def output_item_done_patches(data)
+            item = data[:item] || {}
+
+            case item[:type]
+            when "code_interpreter_call"
+              code_interpreter_done_patches(data[:output_index] || 0, item)
+            when "message"
+              container_file_citation_patches(item)
             else
               []
             end
@@ -100,7 +140,83 @@ module LlmGateway
             part = data[:part] || {}
             return [] unless part.empty? || part[:type] == "output_text"
 
-            [ { type: :text_end, delta: "" } ]
+            citations = container_file_citation_patches(data)
+            return citations unless accumulator.active_block_type == :text
+
+            [ { type: :text_end, delta: "" } ] + citations
+          end
+
+          def code_interpreter_code_delta_patches(data)
+            output_index = data[:output_index] || 0
+            state = code_interpreter_state[output_index] ||= {
+              id: nil,
+              container_id: nil,
+              outputs: nil,
+              input_opened: false,
+              input_closed: false
+            }
+            delta = escape_json_string_fragment(data[:delta] || "")
+            delta = "{\"code\":\"#{delta}" unless state[:input_opened]
+            state[:input_opened] = true
+
+            [ { type: :tool_delta, delta: } ]
+          end
+
+          def code_interpreter_done_patches(output_index, item)
+            state = code_interpreter_state[output_index] ||= {}
+            state[:id] ||= item[:id]
+            state[:container_id] = item[:container_id] if item.key?(:container_id)
+            state[:outputs] = item[:outputs] if item.key?(:outputs)
+            container_id_to_tool_id[state[:container_id]] = state[:id] if state[:container_id] && state[:id]
+            return [] if state[:input_closed]
+
+            opening = state[:input_opened] ? "" : "{\"code\":\""
+            state[:input_opened] = true
+            closing = "\"," + JSON.generate(container_id: state[:container_id], outputs: state[:outputs])[1..]
+            state[:input_closed] = true
+
+            [
+              { type: :tool_delta, delta: opening + closing },
+              { type: :tool_end, delta: "" }
+            ]
+          end
+
+          def container_file_citation_patches(data)
+            extract_annotations(data).filter_map do |annotation|
+              next unless annotation[:type] == "container_file_citation"
+
+              container_id = annotation[:container_id]
+              file_id = annotation[:file_id]
+              filename = annotation[:filename]
+              tool_id = container_id_to_tool_id[container_id]
+              next unless tool_id
+
+              key = [ tool_id, container_id, file_id, filename ]
+              next if emitted_citation_keys[key]
+
+              emitted_citation_keys[key] = true
+              {
+                type: :tool_result_start,
+                delta: JSON.generate(container_id:, file_id:, filename:),
+                tool_use_id: tool_id,
+                name: "container_file_citation_tool_result"
+              }
+            end.flat_map { |start| [ start, { type: :tool_result_end, delta: "" } ] }
+          end
+
+          def extract_annotations(data)
+            annotations = []
+            annotations.concat(Array(data[:annotations]))
+            annotations.concat(Array(data.dig(:part, :annotations)))
+            annotations.concat(Array(data.dig(:item, :annotations)))
+            Array(data.dig(:item, :content)).each do |content_part|
+              annotations.concat(Array(content_part[:annotations])) if content_part.is_a?(Hash)
+            end
+            annotations
+          end
+
+          def escape_json_string_fragment(value)
+            JSON.generate(value)[1...-1]
           end
 
           def response_completed_patches(response)
@@ -162,7 +278,19 @@ module LlmGateway
           end
 
           def tool_seen?
-            accumulator.blocks.any? { |content_block| content_block && content_block[:type] == "tool_use" }
+            accumulator.blocks.any? { |content_block| content_block && [ "tool_use", "server_tool_use" ].include?(content_block[:type]) }
+          end
+
+          def code_interpreter_state
+            @code_interpreter_state ||= {}
+          end
+
+          def container_id_to_tool_id
+            @container_id_to_tool_id ||= {}
+          end
+
+          def emitted_citation_keys
+            @emitted_citation_keys ||= {}
           end
         end
       end