llm_gateway 0.3.0 → 0.4.0

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

@@ -4,9 +4,9 @@ require "base64"
 
 module LlmGateway
   module Adapters
-    module OpenAi
+    module OpenAI
       module Responses
-        class BidirectionalMessageMapper < OpenAi::ChatCompletions::BidirectionalMessageMapper
+        class BidirectionalMessageMapper < OpenAI::ChatCompletions::BidirectionalMessageMapper
           def map_content(content)
             # Convert string content to text format
             #
@@ -15,6 +15,8 @@ module LlmGateway
             case content[:type]
             when "text"
               map_text_content(content)
+            when "image"
+              map_image_content(content)
             when "message"
               map_messages(content)
             when "output_text"
@@ -25,6 +27,8 @@ module LlmGateway
               map_tool_use_content(content)
             when "tool_result"
               map_tool_result_content(content)
+            when "reasoning"
+              map_reasoning_content(content)
             else
               content
             end
@@ -37,10 +41,21 @@ module LlmGateway
           end
 
           def map_tool_result_content(content)
+            output = content[:content]
+            if output.is_a?(Array)
+              output = output.map do |item|
+                if item.is_a?(Hash)
+                  map_content(item.transform_keys(&:to_sym))
+                else
+                  item
+                end
+              end
+            end
+
             {
               "type": "function_call_output",
               "call_id": content[:tool_use_id],
-              "output": content[:content]
+              "output": output
             }
           end
 
@@ -54,17 +69,50 @@ module LlmGateway
 
           def map_output_text_content(content)
             {
-              type: "text",
+              type: direction == LlmGateway::DIRECTION_IN ? "input_text" : "text",
               text: content[:text]
             }
           end
 
+          def map_reasoning_content(content)
+            if direction == LlmGateway::DIRECTION_IN
+              return { id: content[:id] } if content[:id]
+
+              content
+            else
+              {
+                type: "reasoning",
+                reasoning: normalize_reasoning_text(content[:summary]),
+                signature: content[:signature]
+              }
+            end
+          end
+
+          def map_image_content(content)
+            {
+              type: "input_image",
+              image_url: "data:#{content[:media_type]};base64,#{content[:data]}"
+            }
+          end
+
           def map_text_content(content)
             {
               type: "input_text",
               text: content[:text]
             }
           end
+
+          def normalize_reasoning_text(summary)
+            return summary if summary.is_a?(String)
+            return nil unless summary.is_a?(Array)
+            return nil if summary.empty?
+
+            summary.filter_map do |item|
+              next item if item.is_a?(String)
+
+              item[:text] || item[:summary_text] || item[:reasoning]
+            end.join("\n")
+          end
         end
       end
     end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "base64"
+require_relative "bidirectional_message_mapper"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module Responses
+        class InputMapper < OpenAI::ChatCompletions::InputMapper
+          def self.message_mapper
+            BidirectionalMessageMapper.new(LlmGateway::DIRECTION_IN)
+          end
+
+          def self.map_tools(tools)
+            return tools unless tools
+            mapper = message_mapper
+
+            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) ? mapper.map_content(entry.transform_keys(&:to_sym)) : entry
+                end
+              end
+
+              mapped_tool
+            end
+          end
+
+          def self.map_messages(messages)
+            return messages unless messages
+            mapper = message_mapper
+
+            messages.flat_map do |msg|
+              if msg[:id] && msg[:content].is_a?(Array)
+                # Full AssistantMessage#to_h — expand content for stateless multi-turn
+                map_assistant_history_message(msg)
+              elsif msg[:id]
+                # Bare item-reference (e.g. manually constructed { id: "item_xxx" })
+                msg.slice(:id)
+              else
+                content = if msg[:content].is_a?(Array)
+                    msg[:content].map do |content|
+                      mapper.map_content(content)
+                    end
+                else
+                  [ mapper.map_content(msg[:content]) ]
+                end
+                if msg.dig(:content).is_a?(Array) && msg.dig(:content, 0, :type) == "tool_result"
+                  content
+                else
+                  {
+                    role: msg[:role],
+                    content: content
+                  }
+                end
+              end
+            end
+          end
+
+          # Map a full AssistantMessage#to_h into Responses API input items for
+          # stateless multi-turn conversations.
+          #
+          #   text blocks   → { role: "assistant", content: [{ type: "output_text", ... }] }
+          #   tool_use blocks → top-level function_call items
+          #   thinking blocks → omitted (model handles reasoning internally)
+          def self.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
+              }
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module Responses
+        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
+
+            max_completion_tokens = mapped_options.delete(:max_completion_tokens)
+            mapped_options[:max_output_tokens] = max_completion_tokens || mapped_options[:max_output_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: normalize_reasoning(reasoning))
+          end
+
+          def normalize_reasoning(reasoning)
+            effort = reasoning.to_s
+            return { effort: effort, summary: "detailed" } 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}/responses/output_mapper.rb

@@ -5,7 +5,7 @@ require_relative "bidirectional_message_mapper"
 
 module LlmGateway
   module Adapters
-    module OpenAi
+    module OpenAI
       module Responses
         class OutputMapper
           def self.map(data)

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

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+require_relative "../../structs"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      module Responses
+        class StreamMapper
+          def map(chunk)
+            queued_event = shift_queued_event
+            return queued_event if queued_event
+
+            event_type = chunk[:event]
+            data = chunk[:data] || {}
+            raise_stream_error!(data) if event_type == "error" || data[:error] || data[:type] == "error"
+
+            case event_type
+            when "response.created"
+              stash_response(data[:response])
+              nil
+            when "response.output_item.added"
+              map_output_item_added(data)
+            when "response.output_item.done"
+              map_output_item_done(data)
+            when "response.content_part.added"
+              map_content_part_added(data)
+            when "response.content_part.done", "response.output_text.done"
+              map_text_done(data)
+            when "response.output_text.delta"
+              AssistantStreamEvent.new(
+                type: :text_delta,
+                content_index: content_index_for(data[:output_index] || 0),
+                delta: data[:delta] || ""
+              )
+            when "response.function_call_arguments.delta"
+              AssistantStreamEvent.new(
+                type: :tool_delta,
+                content_index: content_index_for(data[:output_index] || 0),
+                delta: data[:delta] || ""
+              )
+            when "response.function_call_arguments.done"
+              map_tool_done(data)
+            when "response.reasoning_summary_text.delta"
+              output_index = data[:output_index] || 0
+              mark_reasoning_has_content(output_index)
+              AssistantStreamReasoningEvent.new(
+                type: :reasoning_delta,
+                content_index: content_index_for(output_index),
+                delta: data[:delta] || "",
+                signature: ""
+              )
+            when "response.completed"
+              map_response_completed(data[:response])
+            else
+              nil
+            end
+          end
+
+          private
+
+          def map_output_item_added(data)
+            item = data[:item] || {}
+            output_index = data[:output_index] || 0
+
+            case item[:type]
+            when "reasoning"
+              mark_reasoning_started(output_index)
+              AssistantStreamReasoningEvent.new(
+                type: :reasoning_start,
+                content_index: register_content_index(output_index),
+                delta: "",
+                signature: ""
+              )
+            when "message"
+              register_content_index(output_index)
+              ensure_message_started(role: item[:role] || "assistant")
+            when "function_call"
+              stash_role("assistant")
+              mark_tool_started(output_index)
+              AssistantToolStartEvent.new(
+                type: :tool_start,
+                content_index: register_content_index(output_index),
+                delta: "",
+                id: item[:call_id] || item[:id],
+                name: item[:name]
+              )
+            else
+              nil
+            end
+          end
+
+          def map_output_item_done(data)
+            item = data[:item] || {}
+            output_index = data[:output_index] || 0
+
+            case item[:type]
+            when "reasoning"
+              map_reasoning_done(output_index, item)
+            when "function_call"
+              map_function_call_done(output_index, item)
+            else
+              nil
+            end
+          end
+
+          def map_reasoning_done(output_index, item)
+            content_index = content_index_for(output_index)
+            summary_text = extract_reasoning_summary_text(item)
+
+            if reasoning_started_without_content?(output_index) && !summary_text.empty?
+              queue_event(
+                AssistantStreamReasoningEvent.new(
+                  type: :reasoning_end,
+                  content_index:,
+                  delta: "",
+                  signature: ""
+                )
+              )
+              mark_reasoning_completed(output_index)
+              return AssistantStreamReasoningEvent.new(
+                type: :reasoning_delta,
+                content_index:,
+                delta: summary_text,
+                signature: ""
+              )
+            end
+
+            mark_reasoning_completed(output_index)
+            AssistantStreamReasoningEvent.new(
+              type: :reasoning_end,
+              content_index:,
+              delta: "",
+              signature: ""
+            )
+          end
+
+          def map_function_call_done(output_index, item)
+            return nil if tool_started?(output_index)
+
+            mark_tool_started(output_index)
+            queue_event(
+              AssistantStreamEvent.new(
+                type: :tool_end,
+                content_index: content_index_for(output_index),
+                delta: ""
+              )
+            )
+
+            AssistantToolStartEvent.new(
+              type: :tool_start,
+              content_index: register_content_index(output_index),
+              delta: "",
+              id: item[:call_id] || item[:id],
+              name: item[:name]
+            )
+          end
+
+          def map_content_part_added(data)
+            part = data[:part] || {}
+            return nil unless part[:type] == "output_text"
+
+            AssistantStreamEvent.new(
+              type: :text_start,
+              content_index: content_index_for(data[:output_index] || 0),
+              delta: ""
+            )
+          end
+
+          def map_text_done(data)
+            AssistantStreamEvent.new(
+              type: :text_end,
+              content_index: content_index_for(data[:output_index] || 0),
+              delta: ""
+            )
+          end
+
+          def map_tool_done(data)
+            AssistantStreamEvent.new(
+              type: :tool_end,
+              content_index: content_index_for(data[:output_index] || 0),
+              delta: ""
+            )
+          end
+
+          def map_response_completed(response)
+            stash_response(response)
+            AssistantStreamMessageEvent.new(
+              type: message_started? ? :message_delta : :message_start,
+              delta: pending_message_attributes.merge(role: pending_message_attributes[:role] || "assistant", stop_reason: stop_reason_for(response)),
+              usage_increment: usage_increment(response)
+            ).tap do
+              @message_started = true
+              clear_pending_message_attributes
+            end
+          end
+
+          def usage_increment(response)
+            usage = response[:usage] || {}
+
+            {
+              input_tokens: usage[:input_tokens] || 0,
+              cache_creation_input_tokens: 0,
+              cache_read_input_tokens: usage.dig(:input_tokens_details, :cached_tokens) || 0,
+              output_tokens: usage[:output_tokens] || 0,
+              reasoning_tokens: usage.dig(:output_tokens_details, :reasoning_tokens) || 0
+            }
+          end
+
+          def stop_reason_for(response)
+            output = response[:output] || []
+            last_item = output.last || {}
+
+            tool_state.any? || last_item[:type] == "function_call" ? "tool_use" : "stop"
+          end
+
+          def ensure_message_started(role: "assistant")
+            return nil if message_started?
+
+            @message_started = true
+            AssistantStreamMessageEvent.new(
+              type: :message_start,
+              delta: pending_message_attributes.merge(role: role).compact,
+              usage_increment: {}
+            ).tap do
+              clear_pending_message_attributes
+            end
+          end
+
+          def extract_reasoning_summary_text(item)
+            Array(item[:summary]).filter_map do |summary|
+              next summary[:text] if summary.is_a?(Hash) && summary[:text]
+              next summary[:summary] if summary.is_a?(Hash) && summary[:summary]
+              next summary if summary.is_a?(String)
+            end.join
+          end
+
+          def mark_reasoning_started(output_index)
+            reasoning_state[output_index] = :started
+          end
+
+          def mark_reasoning_has_content(output_index)
+            reasoning_state[output_index] = :has_content
+          end
+
+          def mark_reasoning_completed(output_index)
+            reasoning_state[output_index] = :completed
+          end
+
+          def reasoning_started_without_content?(output_index)
+            reasoning_state[output_index] == :started
+          end
+
+          def reasoning_state
+            @reasoning_state ||= {}
+          end
+
+          def mark_tool_started(output_index)
+            tool_state[output_index] = :started
+          end
+
+          def tool_started?(output_index)
+            tool_state[output_index] == :started
+          end
+
+          def tool_state
+            @tool_state ||= {}
+          end
+
+          def stash_response(response)
+            response ||= {}
+            @pending_message_attributes = pending_message_attributes.merge(
+              id: response[:id],
+              model: response[:model]
+            ).compact
+          end
+
+          def stash_role(role)
+            @pending_message_attributes = pending_message_attributes.merge(role:)
+          end
+
+          def pending_message_attributes
+            @pending_message_attributes ||= {}
+          end
+
+          def clear_pending_message_attributes
+            @pending_message_attributes = {}
+          end
+
+          def register_content_index(output_index)
+            content_index_map[output_index] ||= next_content_index!
+          end
+
+          def content_index_for(output_index)
+            content_index_map.fetch(output_index) { register_content_index(output_index) }
+          end
+
+          def next_content_index!
+            @next_content_index ||= 0
+            current = @next_content_index
+            @next_content_index += 1
+            current
+          end
+
+          def content_index_map
+            @content_index_map ||= {}
+          end
+
+          def message_started?
+            @message_started ||= false
+          end
+
+          def queue_event(event)
+            queued_events << event
+          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/responses_adapter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../adapter"
+require_relative "acts_like_responses"
+require_relative "../input_message_sanitizer"
+require_relative "responses/input_mapper"
+require_relative "responses/output_mapper"
+require_relative "responses/option_mapper"
+require_relative "file_output_mapper"
+require_relative "responses/stream_mapper"
+
+module LlmGateway
+  module Adapters
+    module OpenAI
+      class ResponsesAdapter < Adapter
+        include ActsLikeOpenAIResponses
+      end
+    end
+  end
+end