llm_gateway 0.4.0 → 0.5.0

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

@@ -1,104 +1,167 @@
 # 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
+          def self.map(data)
+            {
+              messages: map_messages(data[:messages]),
+              tools: map_tools(data[:tools]),
+              system: map_system(data[:system])
+            }
+          end
 
-        private
+          def self.map_content(content)
+            content = { type: "text", text: content } unless content.is_a?(Hash)
 
-        def self.map_messages(messages)
-          return messages unless messages
+            case content[:type]
+            when "text"
+              map_text_content(content)
+            when "file"
+              map_file_content(content)
+            when "image"
+              map_image_content(content)
+            when "tool_use", "function"
+              map_tool_use_content(content)
+            when "tool_result"
+              map_tool_result_content(content)
+            else
+              content
+            end
+          end
+
+          class << self
+            private
 
-          message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_IN)
+            def map_messages(messages)
+              return messages unless messages
 
-          # First map messages like Claude
-          mapped_messages = messages.map do |msg|
-            msg = msg.merge(role: "user") if msg[:role] == "developer"
+              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)
+                content = if msg[:content].is_a?(Array)
+                  msg[:content].map { |content| map_content(content) }
+                else
+                  [ map_content(msg[:content]) ]
                 end
-            else
-              [ message_mapper.map_content(msg[:content]) ]
+
+                {
+                  role: msg[:role],
+                  content: content
+                }
+              end
+
+              mapped_messages.flat_map do |msg|
+                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 = []
+
+                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
+
+                result + tool_messages
+              end
             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
+            def 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
-            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
+
+            def map_system(system)
+              if !system || system.empty?
+                []
+              else
+                system.map do |msg|
+                  msg[:role] == "system" ? msg.merge(role: "developer") : msg
+                end
+              end
             end
 
-            # Add separate tool result messages
-            result += tool_messages
+            def map_text_content(content)
+              {
+                type: "text",
+                text: content[:text]
+              }
+            end
 
-            result
-          end
-        end
+            def map_file_content(content)
+              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 self.map_tools(tools)
-          return tools unless tools
+            def map_image_content(content)
+              {
+                type: "image_url",
+                image_url: {
+                  url: "data:#{content[:media_type]};base64,#{content[:data]}"
+                }
+              }
+            end
 
-          tools.map do |tool|
-            {
-              type: "function",
-              function: {
-                name: tool[:name],
-                description: tool[:description],
-                parameters: tool[:input_schema]
+            def map_tool_use_content(content)
+              {
+                id: content[:id],
+                type: "function",
+                function: {
+                  name: content[:name],
+                  arguments: content[:input].to_json
+                }
               }
-            }
-          end
-        end
+            end
 
-        def self.map_system(system)
-          if !system || system.empty?
-            []
-          else
-            system.map do |msg|
-              msg[:role] == "system" ? msg.merge(role: "developer") : msg
+            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
   end

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

@@ -5,25 +5,115 @@ module LlmGateway
     module OpenAI
       module ChatCompletions
         module OptionMapper
-          include LlmGateway::Adapters::OpenAI::PromptCacheOptionMapper
-
+          DEFAULT_MAX_COMPLETION_TOKENS = 20_480
           VALID_REASONING_LEVELS = %w[low medium high xhigh].freeze
 
+          # Source: https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create/index.md
+          # API: OpenAI Chat Completions Create; accessed 2026-05-18.
+          # Body parameters listed by the API reference: messages, model, audio,
+          # frequency_penalty, function_call, functions, logit_bias, logprobs,
+          # max_completion_tokens, max_tokens, metadata, modalities, n,
+          # parallel_tool_calls, prediction, presence_penalty, prompt_cache_key,
+          # prompt_cache_retention, reasoning_effort, response_format,
+          # safety_identifier, seed, service_tier, stop, store, stream,
+          # stream_options, temperature, tool_choice, tools, top_logprobs, top_p,
+          # user, verbosity, web_search_options.
+          # This mapper intentionally excludes transcript/tool structural fields
+          # (messages, tools) from option handling.
+
+          VALID_OPTIONS = %i[
+            model
+            audio
+            frequency_penalty
+            function_call
+            functions
+            logit_bias
+            logprobs
+            max_completion_tokens
+            max_tokens
+            metadata
+            modalities
+            n
+            parallel_tool_calls
+            prediction
+            presence_penalty
+            prompt_cache_key
+            prompt_cache_retention
+            reasoning_effort
+            response_format
+            safety_identifier
+            seed
+            service_tier
+            stop
+            store
+            stream
+            stream_options
+            temperature
+            tool_choice
+            top_logprobs
+            top_p
+            user
+            verbosity
+            web_search_options
+          ].freeze
+
+          MANAGED_OPTIONS = %i[
+            reasoning
+            cache_key
+            cache_retention
+          ].freeze
+
           module_function
 
           def map(options)
-            mapped_options = options.dup
-            mapped_options[:max_completion_tokens] ||= 20_480
+            mapped_options = options.reject { |key, _| MANAGED_OPTIONS.include?(key) }
+            mapped_options[:max_completion_tokens] = options[:max_completion_tokens] || DEFAULT_MAX_COMPLETION_TOKENS
+
+            cache_key = options[:cache_key]
+            mapped_options[:prompt_cache_key] = cache_key unless cache_key.nil?
+
+            cache_retention = options[:cache_retention]
+            mapped_options[:prompt_cache_retention] = normalize_cache_retention(cache_retention) \
+              unless cache_retention.nil?
 
-            map_cache_key!(mapped_options)
-            map_prompt_cache_retention!(mapped_options)
+            if mapped_options[:prompt_cache_key] && !mapped_options[:prompt_cache_retention]
+              mapped_options[:prompt_cache_retention] = normalize_cache_retention("short")
+            end
 
-            return mapped_options unless mapped_options.key?(:reasoning)
+            if cache_retention.to_s == "none"
+              mapped_options.delete(:prompt_cache_key)
+              mapped_options.delete(:prompt_cache_retention)
+            end
 
-            reasoning = mapped_options.delete(:reasoning)
-            return mapped_options if reasoning.nil? || reasoning.to_s == "none"
+            reasoning = options[:reasoning]
+            mapped_options[:reasoning_effort] = normalize_reasoning_effort(reasoning) \
+              unless reasoning.nil? || reasoning.to_s == "none"
+
+            validate_options!(mapped_options)
+            mapped_options
+          end
+
+          def validate_options!(mapped_options)
+            unknown_options = mapped_options.keys - VALID_OPTIONS
+            return if unknown_options.empty?
+
+            raise ArgumentError,
+                  "Unknown OpenAI Chat Completions options: #{unknown_options.join(', ')}. " \
+                  "Valid options: #{VALID_OPTIONS.join(', ')}."
+          end
 
-            mapped_options.merge(reasoning_effort: normalize_reasoning_effort(reasoning))
+          def normalize_cache_retention(cache_retention)
+            case cache_retention.to_s
+            when "short"
+              "in_memory"
+            when "long"
+              "24h"
+            when "none"
+              nil
+            else
+              raise ArgumentError,
+                    "Invalid cache_retention '#{cache_retention}'. Use 'short', 'long', or 'none'."
+            end
           end
 
           def normalize_reasoning_effort(reasoning)