llm_gateway 0.2.0 → 0.4.0

data/lib/llm_gateway/adapters/anthropic/stream_mapper.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative "../structs.rb"
+
+module LlmGateway
+  module Adapters
+    module Anthropic
+      class StreamMapper
+        def map(chunk)
+          case chunk[:event]
+          when "message_start"
+            delta = {
+              id: chunk.dig(:data, :message, :id),
+              model: chunk.dig(:data, :message, :model),
+              role: chunk.dig(:data, :message, :role)
+            }
+            usage_increment = chunk.dig(:data, :message, :usage) || {}
+
+            AssistantStreamMessageEvent.new(type: :message_start, usage_increment:, delta:)
+          when "content_block_start"
+            content_index = chunk.dig(:data, :index)
+            delta = chunk.dig(:data, :content_block, :text)
+            current_type = chunk.dig(:data, :content_block, :type)
+            content_block_types[content_index] = current_type
+
+            case current_type
+            when "thinking"
+              AssistantStreamEvent.new(type: :reasoning_start, content_index:, delta:)
+            when "text"
+              AssistantStreamEvent.new(type: :text_start, content_index:, delta:)
+            when "tool_use"
+              id = chunk.dig(:data, :content_block, :id)
+              name = chunk.dig(:data, :content_block, :name)
+              AssistantToolStartEvent.new(type: :tool_start, content_index:, delta:, id:, name:)
+            end
+          when "content_block_delta"
+            content_index = chunk.dig(:data, :index)
+
+            case content_block_types[content_index]
+            when "thinking"
+              delta = chunk.dig(:data, :delta, :thinking)
+              signature = chunk.dig(:data, :delta, :signature)
+              AssistantStreamReasoningEvent.new(type: :reasoning_delta, signature:, delta:, content_index:)
+            when "text"
+              delta = chunk.dig(:data, :delta, :text)
+              AssistantStreamEvent.new(type: :text_delta, content_index:, delta:)
+            when "tool_use"
+              delta = chunk.dig(:data, :delta, :partial_json)
+              AssistantStreamEvent.new(type: :tool_delta, content_index:, delta:)
+            end
+          when "content_block_stop"
+            content_index = chunk.dig(:data, :index)
+            type = case content_block_types[content_index]
+            when "thinking"
+              :reasoning_end
+            when "text"
+              :text_end
+            when "tool_use"
+              :tool_end
+            end
+            AssistantStreamEvent.new(type: type, content_index:, delta: "")
+          when "message_delta"
+            delta = normalize_message_delta(chunk.dig(:data, :delta) || {})
+            usage_increment = chunk.dig(:data, :usage) || {}
+
+            AssistantStreamMessageEvent.new(type: :message_delta, usage_increment:, delta:)
+          when "message_stop"
+            AssistantStreamMessageEvent.new(type: :message_end, usage_increment: {}, delta: {})
+          when "ping"
+            nil
+          when "error"
+            error = chunk.dig(:data, :error) || {}
+            message = error[:message] || "Stream error"
+            code = error[:type]
+
+            if LlmGateway::Errors.context_overflow_message?(message)
+              raise LlmGateway::Errors::PromptTooLong.new(message, code)
+            end
+
+            if code == "overloaded_error"
+              raise LlmGateway::Errors::OverloadError.new(message, code)
+            end
+
+            raise LlmGateway::Errors::APIStatusError.new(message, code)
+          end
+        end
+
+        private
+
+        def content_block_types
+          @content_block_types ||= {}
+        end
+
+        def normalize_message_delta(delta)
+          return delta unless delta[:stop_reason] || delta["stop_reason"]
+
+          stop_reason = delta[:stop_reason] || delta["stop_reason"]
+          normalized_stop_reason = case stop_reason
+          when "end_turn"
+            "stop"
+          else
+            stop_reason
+          end
+
+          delta.merge(stop_reason: normalized_stop_reason)
+        end
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/anthropic_option_mapper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module AnthropicOptionMapper
+      DEFAULT_MAX_TOKENS = 20_480
+      REASONING_EFFORT_BUDGET_TOKENS = {
+        "low" => 1024,
+        "medium" => 5 * 1024,
+        "high" => 10 * 1024,
+        "xhigh" => 20 * 1024
+      }.freeze
+
+      module_function
+
+      def map(options)
+        mapped_options = options.reject { |key, _| %i[reasoning max_completion_tokens response_format prompt_cache_retention cache_key prompt_cache_key].include?(key) }
+        mapped_options[:max_tokens] = options[:max_completion_tokens] || DEFAULT_MAX_TOKENS
+
+        retention = options[:cache_retention]
+        mapped_options[:cache_retention] = retention unless retention.nil?
+
+        response_format = options[:response_format]
+        mapped_options[:output_config] = normalize_output_config(response_format) unless response_format.nil?
+
+        reasoning = options[:reasoning]
+        return mapped_options if reasoning.nil? || reasoning.to_s == "none"
+
+        mapped_options[:thinking] = normalize_reasoning(reasoning)
+        mapped_options
+      end
+
+      def normalize_output_config(response_format)
+        format_type = response_format.is_a?(Hash) ? response_format[:type] || response_format["type"] : response_format
+
+        case format_type.to_s
+        when "json_object", "json_schema"
+          { format: "json_schema" }
+        else
+          { format: "text" }
+        end
+      end
+
+      def normalize_reasoning(reasoning)
+        budget_tokens = REASONING_EFFORT_BUDGET_TOKENS[reasoning.to_s] ||
+          raise(ArgumentError,
+                "Invalid reasoning '#{reasoning}'. Use 'none', 'low', 'medium', 'high', or 'xhigh'.")
+
+        { type: "enabled", budget_tokens: budget_tokens }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../adapter"
+require_relative "../openai/acts_like_chat_completions"
+require_relative "../input_message_sanitizer"
+require_relative "../openai/chat_completions/input_mapper"
+require_relative "option_mapper"
+
+module LlmGateway
+  module Adapters
+    module Groq
+      class ChatCompletionsAdapter < Adapter
+        include ActsLikeOpenAIChatCompletions
+
+        private
+
+        def file_output_mapper = nil
+        def stream_mapper = nil
+        def option_mapper = Groq::OptionMapper
+
+        def map_input(input)
+          groq_safe_input = input.dup
+          groq_safe_input[:messages] = Array(input[:messages]).map do |msg|
+            next msg unless msg.is_a?(Hash) && msg[:content].is_a?(Array)
+
+            rewritten_content = msg[:content].map do |block|
+              next block unless block.is_a?(Hash) && block[:type] == "file"
+
+              {
+                type: "text",
+                text: block[:text] || "[File: #{block[:name]}]"
+              }
+            end
+
+            msg.merge(content: rewritten_content)
+          end
+
+          mapped = super(groq_safe_input)
+          mapped[:system] = Array(mapped[:system]).map do |msg|
+            msg[:role] == "developer" ? msg.merge(role: "system") : msg
+          end
+          mapped
+        end
+      end
+    end
+  end
+end

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/openai/chat_completions/bidirectional_message_mapper.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module ChatCompletions
+        class BidirectionalMessageMapper
+        attr_reader :direction
+
+        def initialize(direction)
+          @direction = direction
+        end
+
+        def map_content(content)
+          # Convert string content to text format
+          content = { type: "text", text: content } unless content.is_a?(Hash)
+          case content[:type]
+          when "text"
+            map_text_content(content)
+          when "file"
+            map_file_content(content)
+          when "image"
+            map_image_content(content)
+          when "tool_use"
+            map_tool_use_content(content)
+          when "function"
+            map_tool_use_content(content)
+          when "tool_result"
+            map_tool_result_content(content)
+          else
+            content
+          end
+        end
+
+        private
+
+        def parse_tool_arguments(arguments)
+          return arguments unless arguments.is_a?(String)
+          JSON.parse(arguments, symbolize_names: true)
+        end
+
+        def map_text_content(content)
+          {
+            type: "text",
+            text: content[:text]
+          }
+        end
+
+        def map_file_content(content)
+          # Map text/plain to application/pdf for OpenAI
+          media_type = content[:media_type] == "text/plain" ? "application/pdf" : content[:media_type]
+          {
+            type: "file",
+            file: {
+              filename: content[:name],
+              file_data: "data:#{media_type};base64,#{Base64.encode64(content[:data])}"
+            }
+          }
+        end
+
+        def map_image_content(content)
+          {
+            type: "image_url",
+            image_url: {
+              url: "data:#{content[:media_type]};base64,#{content[:data]}"
+            }
+          }
+        end
+
+        def map_tool_use_content(content)
+          if direction == LlmGateway::DIRECTION_IN
+          {
+            id: content[:id],
+            type: "function",
+            function: {
+              name: content[:name],
+              arguments: content[:input].to_json
+            }
+          }
+          else
+          {
+            id: content[:id],
+            type: "tool_use",
+            name: content[:function][:name],
+            input: parse_tool_arguments(content[:function][:arguments])
+          }
+          end
+        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: mapped_content
+          }
+        end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "base64"
+require_relative "bidirectional_message_mapper"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module ChatCompletions
+        class InputMapper
+        def self.map(data)
+          {
+            messages: map_messages(data[:messages]),
+            tools: map_tools(data[:tools]),
+            system: map_system(data[:system])
+          }
+        end
+
+        private
+
+        def self.map_messages(messages)
+          return messages unless messages
+
+          message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_IN)
+
+          # First map messages like Claude
+          mapped_messages = messages.map do |msg|
+            msg = msg.merge(role: "user") if msg[:role] == "developer"
+
+            content = if msg[:content].is_a?(Array)
+                msg[:content].map do |content|
+                  message_mapper.map_content(content)
+                end
+            else
+              [ message_mapper.map_content(msg[:content]) ]
+            end
+
+            {
+              role: msg[:role],
+              content: content
+            }
+          end
+          # Then transform to OpenAI format
+          mapped_messages.flat_map do |msg|
+            # Handle array content with tool calls and tool results
+            tool_calls = []
+            regular_content = []
+            tool_messages = []
+            msg[:content].each do |content|
+              case content[:type] || content[:role]
+              when "tool"
+                tool_messages << content
+              when "function"
+                tool_calls << content
+              else
+                regular_content << content
+              end
+            end
+            result = []
+
+            # Add the main message with tool calls if any
+            if tool_calls.any? || regular_content.any?
+              main_msg = msg.dup
+              main_msg[:role] = "assistant" if !main_msg[:role]
+              main_msg[:tool_calls] = tool_calls if tool_calls.any?
+              main_msg[:content] = regular_content.any? ? regular_content : nil
+              result << main_msg
+            end
+
+            # Add separate tool result messages
+            result += tool_messages
+
+            result
+          end
+        end
+
+        def self.map_tools(tools)
+          return tools unless tools
+
+          tools.map do |tool|
+            {
+              type: "function",
+              function: {
+                name: tool[:name],
+                description: tool[:description],
+                parameters: tool[:input_schema]
+              }
+            }
+          end
+        end
+
+        def self.map_system(system)
+          if !system || system.empty?
+            []
+          else
+            system.map do |msg|
+              msg[:role] == "system" ? msg.merge(role: "developer") : msg
+            end
+          end
+        end
+        end
+      end
+    end
+  end
+end

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