llm_gateway 0.3.0 → 0.4.0

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module Groq
+      module OptionMapper
+        module_function
+
+        def map(options)
+          mapped_options = options.dup
+          mapped_options[:temperature] ||= 0
+          mapped_options[:max_completion_tokens] ||= 20480
+          mapped_options[:response_format] = normalize_response_format(mapped_options[:response_format] || "text")
+          mapped_options
+        end
+
+        def normalize_response_format(response_format)
+          if response_format.is_a?(String)
+            { type: response_format }
+          else
+            response_format
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/input_message_sanitizer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+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|
+          sanitize_message(
+            message,
+            target_provider: target_provider,
+            target_api: target_api,
+            target_model: target_model
+          )
+        end
+      end
+
+      def self.sanitize_message(message, target_provider:, target_api:, target_model:)
+        return message unless message.is_a?(Hash)
+
+        role = message[:role] || message["role"]
+        content = message[:content] || message["content"]
+        return message unless role == "assistant" && content.is_a?(Array)
+        return message unless message_metadata_present?(message)
+
+        same_model_replay = same_model_replay?(message, target_provider:, target_api:, target_model:)
+
+        sanitized_content = content.each_with_object([]) do |block, acc|
+          sanitized = sanitize_content_block(block, same_model_replay: same_model_replay)
+          next if sanitized.nil?
+
+          if sanitized.is_a?(Array)
+            acc.concat(sanitized)
+          else
+            acc << sanitized
+          end
+        end
+
+        message.merge(content: sanitized_content)
+      end
+
+      def self.sanitize_content_block(block, same_model_replay:)
+        return block unless block.is_a?(Hash)
+
+        type = block[:type] || block["type"]
+        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?
+
+        { type: "text", text: text }
+      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)
+
+        summary = block[:summary]
+        if summary.is_a?(Array)
+          text = summary.filter_map do |item|
+            next item if item.is_a?(String)
+            next unless item.is_a?(Hash)
+
+            item[:text] || item[:summary_text] || item[:reasoning]
+          end.join("\n")
+          return text unless text.empty?
+        end
+
+        nil
+      end
+
+      def self.same_model_replay?(message, target_provider:, target_api:, target_model:)
+        provider = message[:provider] || message["provider"]
+        api = message[:api] || message["api"]
+        model = message[:model] || message["model"]
+
+        provider == target_provider && api == target_api && model == target_model
+      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?
+      end
+
+      private_class_method :sanitize_message, :sanitize_content_block, :extract_reasoning_text, :same_model_replay?, :message_metadata_present?
+    end
+  end
+end

data/lib/llm_gateway/adapters/openai/acts_like_chat_completions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module ActsLikeOpenAIChatCompletions
+      private
+      def api_name = "completions"
+
+      def input_mapper = OpenAI::ChatCompletions::InputMapper
+
+      def input_sanitizer = OpenAI::ChatCompletions::InputMessageSanitizer
+
+      def output_mapper = OpenAI::ChatCompletions::OutputMapper
+
+      def file_output_mapper = OpenAI::FileOutputMapper
+
+      def option_mapper = OpenAI::ChatCompletions::OptionMapper
+
+      def stream_mapper = OpenAI::ChatCompletions::StreamMapper
+    end
+  end
+end

data/lib/llm_gateway/adapters/openai/acts_like_responses.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module ActsLikeOpenAIResponses
+      private
+
+      def api_name = "responses"
+
+      def input_mapper = OpenAI::Responses::InputMapper
+
+      def input_sanitizer = InputMessageSanitizer
+
+      def output_mapper = OpenAI::Responses::OutputMapper
+
+      def file_output_mapper = OpenAI::FileOutputMapper
+
+      def option_mapper = OpenAI::Responses::OptionMapper
+
+      def stream_mapper = OpenAI::Responses::StreamMapper
+
+      def perform_chat(messages, tools:, system:, **options)
+        client.responses(messages, tools: tools, system: system, **options)
+      end
+
+      def perform_stream(messages, tools:, system:, **options, &block)
+        client.stream_responses(messages, tools: tools, system: system, **options, &block)
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/{open_ai → openai}/chat_completions/bidirectional_message_mapper.rb

@@ -4,7 +4,7 @@ require "base64"
 
 module LlmGateway
   module Adapters
-    module OpenAi
+    module OpenAI
       module ChatCompletions
         class BidirectionalMessageMapper
         attr_reader :direction
@@ -90,10 +90,17 @@ module LlmGateway
         end
 
         def map_tool_result_content(content)
+          mapped_content = content[:content]
+          if mapped_content.is_a?(Array)
+            mapped_content = mapped_content.map do |item|
+              item.is_a?(Hash) ? map_content(item.transform_keys(&:to_sym)) : item
+            end
+          end
+
           {
             role: "tool",
             tool_call_id: content[:tool_use_id],
-            content: content[:content]
+            content: mapped_content
           }
         end
         end

data/lib/llm_gateway/adapters/{open_ai → openai}/chat_completions/input_mapper.rb

@@ -5,13 +5,12 @@ require_relative "bidirectional_message_mapper"
 
 module LlmGateway
   module Adapters
-    module OpenAi
+    module OpenAI
       module ChatCompletions
         class InputMapper
         def self.map(data)
           {
             messages: map_messages(data[:messages]),
-            response_format: map_response_format(data[:response_format]),
             tools: map_tools(data[:tools]),
             system: map_system(data[:system])
           }
@@ -19,10 +18,6 @@ module LlmGateway
 
         private
 
-        def self.map_response_format(response_format)
-          response_format
-        end
-
         def self.map_messages(messages)
           return messages unless messages
 

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../../input_message_sanitizer"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module ChatCompletions
+        class InputMessageSanitizer < LlmGateway::Adapters::InputMessageSanitizer
+          def self.sanitize(messages, target_provider:, target_api:, target_model:)
+            sanitized = super
+            normalize_tool_call_ids(sanitized, target_provider: target_provider)
+          end
+
+          def self.normalize_tool_call_ids(messages, target_provider:)
+            return messages unless messages.is_a?(Array)
+
+            id_map = {}
+
+            messages.map do |message|
+              next message unless message.is_a?(Hash) && message[:content].is_a?(Array)
+
+              content = message[:content].map do |block|
+                next block unless block.is_a?(Hash)
+
+                type = block[:type] || block["type"]
+
+                case type
+                when "tool_use", "function"
+                  original_id = block[:id] || block["id"]
+                  normalized_id = normalize_tool_call_id(original_id, target_provider: target_provider)
+                  id_map[original_id] = normalized_id if original_id && normalized_id
+                  block.merge(id: normalized_id)
+                when "tool_result"
+                  original_tool_use_id = block[:tool_use_id] || block["tool_use_id"]
+                  normalized_tool_use_id = id_map[original_tool_use_id] || normalize_tool_call_id(original_tool_use_id, target_provider: target_provider)
+                  block.merge(tool_use_id: normalized_tool_use_id)
+                else
+                  block
+                end
+              end
+
+              message.merge(content: content)
+            end
+          end
+
+          def self.normalize_tool_call_id(id, target_provider:)
+            return id unless id.is_a?(String)
+
+            if id.include?("|")
+              call_id = id.split("|", 2).first
+              call_id.gsub(/[^a-zA-Z0-9_-]/, "_")[0, 40]
+            elsif target_provider == "openai"
+              id[0, 40]
+            else
+              id
+            end
+          end
+
+          private_class_method :normalize_tool_call_ids, :normalize_tool_call_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module ChatCompletions
+        module OptionMapper
+          include LlmGateway::Adapters::OpenAI::PromptCacheOptionMapper
+
+          VALID_REASONING_LEVELS = %w[low medium high xhigh].freeze
+
+          module_function
+
+          def map(options)
+            mapped_options = options.dup
+            mapped_options[:max_completion_tokens] ||= 20_480
+
+            map_cache_key!(mapped_options)
+            map_prompt_cache_retention!(mapped_options)
+
+            return mapped_options unless mapped_options.key?(:reasoning)
+
+            reasoning = mapped_options.delete(:reasoning)
+            return mapped_options if reasoning.nil? || reasoning.to_s == "none"
+
+            mapped_options.merge(reasoning_effort: normalize_reasoning_effort(reasoning))
+          end
+
+          def normalize_reasoning_effort(reasoning)
+            effort = reasoning.to_s
+            return effort if VALID_REASONING_LEVELS.include?(effort)
+
+            raise ArgumentError, "Invalid reasoning '#{reasoning}'. Use 'none', 'low', 'medium', 'high', or 'xhigh'."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/{open_ai → openai}/chat_completions/output_mapper.rb

@@ -2,7 +2,7 @@
 
 module LlmGateway
   module Adapters
-    module OpenAi
+    module OpenAI
       module ChatCompletions
         class OutputMapper
         def self.map(data)

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

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require_relative "../../structs"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module ChatCompletions
+        class StreamMapper
+          def map(chunk)
+            queued_event = shift_queued_event
+            return queued_event if queued_event
+
+            data = chunk[:data] || {}
+            raise_stream_error!(data) if chunk[:event] == "error" || data[:error] || data[:type] == "error"
+
+            choices = data[:choices] || []
+
+            if choices.empty?
+              return message_event(
+                delta: pending_finish_delta,
+                usage_increment: usage_increment(data)
+              )
+            end
+
+            choice = choices.first || {}
+            delta = choice[:delta] || {}
+            finish_reason = choice[:finish_reason]
+
+            event = map_choice_delta(data, choice, delta)
+            return event if event
+
+            return finish_event_for(finish_reason) if finish_reason
+
+            nil
+          end
+
+          private
+
+          def map_choice_delta(data, choice, delta)
+            if !message_started? && delta[:tool_calls]&.any?
+              @message_started = true
+              stash_message_attributes(data, delta)
+              return tool_event(delta[:tool_calls].first)
+            end
+
+            if !message_started? && (delta.key?(:role) || data[:id] || data[:model])
+              @message_started = true
+              return AssistantStreamMessageEvent.new(
+                type: :message_start,
+                delta: {
+                  id: data[:id],
+                  model: data[:model],
+                  role: delta[:role]
+                }.compact,
+                usage_increment: {}
+              )
+            end
+
+            if (content = delta[:content]) && !content.empty?
+              return text_event(content, choice[:index] || 0)
+            end
+
+            return tool_event(delta[:tool_calls].first) if delta[:tool_calls]&.any?
+
+            nil
+          end
+
+          def finish_event_for(finish_reason)
+            normalized = normalize_stop_reason(finish_reason)
+            stash_pending_finish_delta(stop_reason: normalized)
+
+            case normalized
+            when "tool_use"
+              AssistantStreamEvent.new(type: :tool_end, content_index: last_started_tool_index || 0, delta: "")
+            else
+              AssistantStreamEvent.new(type: :text_end, content_index: last_started_text_index || 0, delta: "")
+            end
+          end
+
+          def message_event(delta:, usage_increment: {})
+            AssistantStreamMessageEvent.new(
+              type: pending_message_attributes.empty? ? :message_delta : :message_start,
+              delta: pending_message_attributes.merge(delta),
+              usage_increment:
+            ).tap do
+              clear_pending_message_attributes
+              clear_pending_finish_delta
+            end
+          end
+
+          def usage_increment(data)
+            usage = data[:usage] || {}
+
+            {
+              input_tokens: usage[:prompt_tokens] || 0,
+              cache_creation_input_tokens: 0,
+              cache_read_input_tokens: usage.dig(:prompt_tokens_details, :cached_tokens) || 0,
+              output_tokens: usage[:completion_tokens] || 0,
+              reasoning_tokens: usage.dig(:completion_tokens_details, :reasoning_tokens) || 0
+            }
+          end
+
+          def text_event(content, content_index)
+            @last_started_text_index = content_index
+
+            if started_text_blocks.include?(content_index)
+              AssistantStreamEvent.new(type: :text_delta, content_index:, delta: content)
+            else
+              started_text_blocks << content_index
+              AssistantStreamEvent.new(type: :text_start, content_index:, delta: content)
+            end
+          end
+
+          def tool_event(tool_call)
+            tool_index = tool_call[:index] || 0
+            @last_started_tool_index = tool_index
+            function = tool_call[:function] || {}
+            arguments = function[:arguments] || ""
+
+            unless started_tool_blocks.include?(tool_index)
+              pending_tool_calls[tool_index] = merge_tool_call(pending_tool_calls[tool_index], tool_call)
+              pending = pending_tool_calls[tool_index]
+
+              return nil unless pending[:id] && pending.dig(:function, :name)
+
+              started_tool_blocks << tool_index
+              return AssistantToolStartEvent.new(
+                type: :tool_start,
+                content_index: tool_index,
+                delta: "",
+                id: pending[:id],
+                name: pending.dig(:function, :name)
+              )
+            end
+
+            AssistantStreamEvent.new(type: :tool_delta, content_index: tool_index, delta: arguments)
+          end
+
+          def stash_message_attributes(data, delta)
+            @pending_message_attributes = {
+              id: data[:id],
+              model: data[:model],
+              role: delta[:role]
+            }.compact
+          end
+
+          def pending_message_attributes
+            @pending_message_attributes ||= {}
+          end
+
+          def clear_pending_message_attributes
+            @pending_message_attributes = {}
+          end
+
+          def stash_pending_finish_delta(delta)
+            @pending_finish_delta = pending_finish_delta.merge(delta)
+          end
+
+          def pending_finish_delta
+            @pending_finish_delta ||= {}
+          end
+
+          def clear_pending_finish_delta
+            @pending_finish_delta = {}
+          end
+
+          def merge_tool_call(existing, incoming)
+            existing ||= {}
+            incoming ||= {}
+
+            existing_function = existing[:function] || {}
+            incoming_function = incoming[:function] || {}
+
+            {
+              index: incoming[:index] || existing[:index],
+              id: incoming[:id] || existing[:id],
+              type: incoming[:type] || existing[:type],
+              function: {
+                name: incoming_function[:name] || existing_function[:name],
+                arguments: "#{existing_function[:arguments]}#{incoming_function[:arguments]}"
+              }
+            }
+          end
+
+          def normalize_stop_reason(finish_reason)
+            case finish_reason
+            when "tool_calls"
+              "tool_use"
+            else
+              finish_reason
+            end
+          end
+
+          def message_started?
+            @message_started ||= false
+          end
+
+          def started_text_blocks
+            @started_text_blocks ||= []
+          end
+
+          def started_tool_blocks
+            @started_tool_blocks ||= []
+          end
+
+          def pending_tool_calls
+            @pending_tool_calls ||= {}
+          end
+
+          def last_started_text_index
+            @last_started_text_index
+          end
+
+          def last_started_tool_index
+            @last_started_tool_index
+          end
+
+          def shift_queued_event
+            queued_events.shift
+          end
+
+          def queued_events
+            @queued_events ||= []
+          end
+
+          def raise_stream_error!(data)
+            error = data[:error].is_a?(Hash) ? data[:error] : data
+            message = error[:message] || "Stream error"
+            code = error[:code] || error[:type]
+
+            if LlmGateway::Errors.context_overflow_message?(message)
+              raise LlmGateway::Errors::PromptTooLong.new(message, code)
+            end
+
+            raise LlmGateway::Errors::APIStatusError.new(message, code)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/openai/chat_completions_adapter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../adapter"
+require_relative "acts_like_chat_completions"
+require_relative "chat_completions/input_mapper"
+require_relative "chat_completions/input_message_sanitizer"
+require_relative "chat_completions/output_mapper"
+require_relative "chat_completions/option_mapper"
+require_relative "file_output_mapper"
+require_relative "chat_completions/stream_mapper"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      class ChatCompletionsAdapter < Adapter
+        include ActsLikeOpenAIChatCompletions
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/{open_ai → openai}/file_output_mapper.rb

@@ -2,7 +2,7 @@
 
 module LlmGateway
   module Adapters
-    module OpenAi
+    module OpenAI
       class FileOutputMapper
         def self.map(data)
           bytes = data.delete(:bytes)

data/lib/llm_gateway/adapters/openai/prompt_cache_option_mapper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module PromptCacheOptionMapper
+        def self.included(base)
+          base.extend(self)
+        end
+
+        def map_cache_key!(mapped_options)
+          cache_key = mapped_options.delete(:cache_key)
+          mapped_options.delete(:prompt_cache_key)
+          mapped_options[:prompt_cache_key] = cache_key unless cache_key.nil?
+        end
+
+        def map_prompt_cache_retention!(mapped_options)
+          retention = mapped_options.delete(:cache_retention)
+          mapped_options.delete(:prompt_cache_retention)
+          retention ||= "short" if mapped_options.key?(:prompt_cache_key)
+
+          case retention&.to_s
+          when nil
+            nil
+          when "short"
+            mapped_options[:prompt_cache_retention] = "in_memory"
+          when "long"
+            mapped_options[:prompt_cache_retention] = "24h"
+          when "none"
+            mapped_options.delete(:prompt_cache_key)
+          else
+            raise ArgumentError,
+              "Invalid cache_retention '#{retention}'. Use 'short', 'long', or 'none'."
+          end
+        end
+      end
+    end
+  end
+end