llm_gateway 0.4.0 → 0.5.0

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

@@ -1,185 +1,228 @@
 # frozen_string_literal: true
 
-require_relative "../../structs"
+require_relative "../../stream_mapper"
 
 module LlmGateway
   module Adapters
     module OpenAI
       module ChatCompletions
-        class StreamMapper
-          def map(chunk)
-            queued_event = shift_queued_event
-            return queued_event if queued_event
-
+        class StreamMapper < LlmGateway::Adapters::StreamMapper
+          def map(chunk, &block)
             data = chunk[:data] || {}
             raise_stream_error!(data) if chunk[:event] == "error" || data[:error] || data[:type] == "error"
 
-            choices = data[:choices] || []
+            push_patches(patches_for(data), &block)
+          end
 
-            if choices.empty?
-              return message_event(
-                delta: pending_finish_delta,
-                usage_increment: usage_increment(data)
-              )
-            end
+          private
+
+          def patches_for(data)
+            choices = data[:choices] || []
+            return final_usage_patches(data) if choices.empty?
 
             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
+            patches = []
+            active_block_type = accumulator.active_block_type
+            active_tool = active_tool_block
+
+            append_patches(patches, message_start_patches(data, delta))
+
+            active_block_type, active_tool = append_patches(
+              patches,
+              reasoning_patches(delta[:reasoning], active_block_type:),
+              active_block_type,
+              active_tool
+            )
+            active_block_type, active_tool = append_patches(
+              patches,
+              text_patches(delta[:content], active_block_type:),
+              active_block_type,
+              active_tool
+            )
+            delta.fetch(:tool_calls, []).each do |tool_call|
+              active_block_type, active_tool = append_patches(
+                patches,
+                patches_for_tool_call(tool_call, active_block_type:, active_tool:),
+                active_block_type,
+                active_tool
+              )
+            end
+            append_patches(patches, finish_patches(choice[:finish_reason], active_block_type:))
+
+            patches
+          end
+
+          def append_patches(patches, new_patches, active_block_type = nil, active_tool = nil)
+            patches.concat(new_patches)
+
+            new_patches.each do |patch|
+              case patch[:type]
+              when :text_start
+                active_block_type = :text
+                active_tool = nil
+              when :reasoning_start
+                active_block_type = :reasoning
+                active_tool = nil
+              when :tool_start
+                active_block_type = :tool
+                active_tool = { id: patch[:id], name: patch[:name] }
+              when :text_end, :reasoning_end, :tool_end
+                active_block_type = nil
+                active_tool = nil
+              end
+            end
 
-            nil
+            [ active_block_type, active_tool ]
           end
 
-          private
+          def message_start_patches(data, delta)
+            return [] unless accumulator.message_hash.empty?
 
-          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
+            return [] unless delta.key?(:role) ||
+                             data[:id] ||
+                             data[:model] ||
+                             delta[:content] ||
+                             delta[:reasoning] ||
+                             delta[:tool_calls]&.any?
 
-            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]
+                  role: delta[:role] || "assistant"
                 }.compact,
                 usage_increment: {}
-              )
-            end
-
-            if (content = delta[:content]) && !content.empty?
-              return text_event(content, choice[:index] || 0)
-            end
+              }
+            ]
+          end
 
-            return tool_event(delta[:tool_calls].first) if delta[:tool_calls]&.any?
+          # Groq exposes OpenAI-compatible chat completion chunks, but may include
+          # `delta.reasoning` before normal `delta.content`.
+          def reasoning_patches(reasoning, active_block_type: accumulator.active_block_type)
+            return [] if reasoning.to_s.empty?
 
-            nil
+            [
+              *close_active_non_reasoning_patches(active_block_type:),
+              {
+                type: active_block_type == :reasoning ? :reasoning_delta : :reasoning_start,
+                delta: reasoning,
+                signature: ""
+              }
+            ]
           end
 
-          def finish_event_for(finish_reason)
-            normalized = normalize_stop_reason(finish_reason)
-            stash_pending_finish_delta(stop_reason: normalized)
+          def text_patches(content, active_block_type: accumulator.active_block_type)
+            return [] if content.to_s.empty?
 
-            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: "")
+            [
+              *close_active_non_text_patches(active_block_type:),
+              {
+                type: active_block_type == :text ? :text_delta : :text_start,
+                delta: content
+              }
+            ]
+          end
+
+          def patches_for_tool_call(tool_call, active_block_type: accumulator.active_block_type, active_tool: active_tool_block)
+            id = tool_call[:id]
+            name = tool_call.dig(:function, :name)
+            arguments = tool_call.dig(:function, :arguments).to_s
+
+            patches = []
+
+            if id || name
+              if active_block_type == :tool
+                patches.concat(close_active_block_patches(active_block_type:)) if new_active_tool?(id, name, active_tool:)
+              else
+                patches.concat(close_active_non_tool_patches(active_block_type:))
+              end
+
+              unless active_block_type == :tool && patches.empty?
+                patches << {
+                  type: :tool_start,
+                  delta: "",
+                  id: id,
+                  name: name
+                }
+              end
             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
+            patches << { type: :tool_delta, delta: arguments } unless arguments.empty?
+            patches
           end
 
-          def usage_increment(data)
-            usage = data[:usage] || {}
+          def new_active_tool?(id, name, active_tool: active_tool_block)
+            return true unless active_tool
 
-            {
-              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
-            }
+            (id && active_tool[:id] != id) || (name && active_tool[:name] != name)
           end
 
-          def text_event(content, content_index)
-            @last_started_text_index = content_index
+          def active_tool_block
+            return nil unless accumulator.active_tool?
 
-            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
+            accumulator.blocks.reverse.find { |block| block&.fetch(:type, nil) == "tool_use" }
           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)
-              )
+          def close_active_block_patches(active_block_type: accumulator.active_block_type)
+            case active_block_type
+            when :text
+              [ { type: :text_end, delta: "" } ]
+            when :reasoning
+              [ { type: :reasoning_end, delta: "", signature: "" } ]
+            when :tool
+              [ { type: :tool_end, delta: "" } ]
+            else
+              []
             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
+          def close_active_non_text_patches(active_block_type: accumulator.active_block_type)
+            active_block_type == :text ? [] : close_active_block_patches(active_block_type:)
           end
 
-          def pending_message_attributes
-            @pending_message_attributes ||= {}
+          def close_active_non_reasoning_patches(active_block_type: accumulator.active_block_type)
+            active_block_type == :reasoning ? [] : close_active_block_patches(active_block_type:)
           end
 
-          def clear_pending_message_attributes
-            @pending_message_attributes = {}
+          def close_active_non_tool_patches(active_block_type: accumulator.active_block_type)
+            active_block_type == :tool ? [] : close_active_block_patches(active_block_type:)
           end
 
-          def stash_pending_finish_delta(delta)
-            @pending_finish_delta = pending_finish_delta.merge(delta)
-          end
+          def finish_patches(finish_reason, active_block_type: accumulator.active_block_type)
+            return [] unless finish_reason
 
-          def pending_finish_delta
-            @pending_finish_delta ||= {}
+            [
+              *close_active_block_patches(active_block_type:),
+              {
+                type: :message_delta,
+                delta: { stop_reason: normalize_stop_reason(finish_reason) },
+                usage_increment: {}
+              }
+            ]
           end
 
-          def clear_pending_finish_delta
-            @pending_finish_delta = {}
+          def final_usage_patches(data)
+            [
+              {
+                type: accumulator.message_hash.empty? ? :message_start : :message_delta,
+                delta: {},
+                usage_increment: usage_increment(data)
+              }
+            ]
           end
 
-          def merge_tool_call(existing, incoming)
-            existing ||= {}
-            incoming ||= {}
-
-            existing_function = existing[:function] || {}
-            incoming_function = incoming[:function] || {}
+          def usage_increment(data)
+            usage = data[:usage] || {}
 
             {
-              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]}"
-              }
+              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
 
@@ -191,50 +234,6 @@ module LlmGateway
               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

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

@@ -4,7 +4,6 @@ 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"

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

@@ -1,103 +1,163 @@
 # 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)
+          def self.map_content(content)
+            content = { type: "text", text: content } unless content.is_a?(Hash)
+
+            case content[:type]
+            when "text"
+              map_text_content(content)
+            when "image"
+              map_image_content(content)
+            when "message"
+              map_messages_content(content)
+            when "output_text"
+              map_output_text_content(content)
+            when "tool_use", "function_call"
+              map_tool_use_content(content)
+            when "tool_result"
+              map_tool_result_content(content)
+            when "reasoning"
+              map_reasoning_content(content)
+            else
+              content
+            end
           end
 
-          def self.map_tools(tools)
-            return tools unless tools
-            mapper = message_mapper
+          class << self
+            private
 
-            tools.map do |tool|
-              mapped_tool = {
-                type: "function",
-                name: tool[:name],
-                description: tool[:description],
-                parameters: tool[:input_schema]
-              }
+            def map_tools(tools)
+              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)
+                [ :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
+                  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
 
-          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
+            def map_messages(messages)
+              return messages unless messages
+
+              messages.flat_map do |msg|
+                if msg[:id] && msg[:content].is_a?(Array)
+                  map_assistant_history_message(msg)
+                elsif msg[:id]
+                  msg.slice(:id)
                 else
-                  {
-                    role: msg[:role],
-                    content: content
-                  }
+                  content = if msg[:content].is_a?(Array)
+                    msg[:content].map { |content| map_content(content) }
+                  else
+                    [ 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
-          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) }
+            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
+                }
+              end
+
+              result
+            end
+
+            def map_messages_content(message)
+              message[:content].map { |content| map_content(content) }
+            end
+
+            def map_tool_result_content(content)
+              output = content[:content]
+              if output.is_a?(Array)
+                output = output.map do |item|
+                  item.is_a?(Hash) ? map_content(item.transform_keys(&:to_sym)) : item
+                end
+              end
 
-            text_blocks     = blocks.select { |b| b[:type] == "text" }
-            tool_use_blocks = blocks.select { |b| b[:type] == "tool_use" }
+              {
+                type: "function_call_output",
+                call_id: content[:tool_use_id],
+                output: output
+              }
+            end
 
-            result = []
+            def map_tool_use_content(content)
+              { id: content[:id] }
+            end
 
-            if text_blocks.any?
-              result << {
-                role: "assistant",
-                content: text_blocks.map { |b| { type: "output_text", text: b[:text] } }
+            def map_output_text_content(content)
+              {
+                type: "input_text",
+                text: content[: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
+            def map_reasoning_content(content)
+              return { id: content[:id] } if content[:id]
+
+              content
+            end
+
+            def map_image_content(content)
+              {
+                type: "input_image",
+                image_url: "data:#{content[:media_type]};base64,#{content[:data]}"
               }
             end
 
-            result
+            def map_text_content(content)
+              {
+                type: "input_text",
+                text: content[:text]
+              }
+            end
           end
         end
       end