llm_gateway 0.4.0 → 0.5.0

data/lib/llm_gateway/client.rb

@@ -1,24 +1,17 @@
 # frozen_string_literal: true
 
+
 module LlmGateway
   class Client
-    def self.chat(model, message, tools: nil, system: nil, api_key: nil, refresh_token: nil, expires_at: nil, **options)
-      adapter = build_adapter_from_model(model, api_key: api_key, refresh_token: refresh_token, expires_at: expires_at)
-      adapter.chat(message, tools: tools, system: system, **options)
-    end
-
-    def self.responses(model, message, tools: nil, system: nil, api_key: nil, **options)
-      adapter = build_adapter_from_model(model, api_key: api_key, api: "responses")
-      adapter.chat(message, tools: tools, system: system, **options)
-    end
-
-    def self.build_client(provider, api_key:, model: "none")
-      adapter = LlmGateway.build_provider(
-        provider: provider,
-        api_key: api_key,
-        model_key: model
-      )
-      adapter.client
+    def self.provider_id_from_client(client)
+      case client
+      when LlmGateway::Clients::Anthropic
+        "anthropic"
+      when LlmGateway::Clients::OpenAI
+        "openai"
+      when LlmGateway::Clients::Groq
+        "groq"
+      end
     end
 
     def self.upload_file(provider, **kwargs)
@@ -38,54 +31,5 @@ module LlmGateway
       )
       adapter.download_file(**kwargs)
     end
-
-    def self.provider_from_model(model)
-      return "anthropic" if model.start_with?("claude")
-      return "groq" if model.start_with?("llama")
-      return "openai" if model.start_with?("gpt") ||
-                         model.start_with?("o4-") ||
-                         model.start_with?("openai")
-
-      raise LlmGateway::Errors::UnsupportedModel, model
-    end
-
-    def self.provider_id_from_client(client)
-      case client
-      when LlmGateway::Clients::Anthropic
-        "anthropic"
-      when LlmGateway::Clients::OpenAI
-        "openai"
-      when LlmGateway::Clients::Groq
-        "groq"
-      else
-        client.class.name.downcase
-      end
-    end
-
-    # --- private helpers ---
-
-    def self.build_adapter_from_model(model, api_key: nil, refresh_token: nil, expires_at: nil, api: nil)
-      provider = provider_from_model(model)
-
-      if api == "responses"
-        config = {
-          provider: "#{provider}_responses",
-          model_key: model
-        }
-        config[:api_key] = api_key if api_key
-        LlmGateway.build_provider(config)
-      else
-        provider_key = case provider
-        when "anthropic" then "anthropic_messages"
-        when "openai" then "openai_completions"
-        when "groq" then "groq_completions"
-        end
-        config = { provider: provider_key, model_key: model }
-        config[:api_key] = api_key if api_key
-        LlmGateway.build_provider(config)
-      end
-    end
-
-    private_class_method :build_adapter_from_model
   end
 end

data/lib/llm_gateway/clients/groq.rb

@@ -5,7 +5,7 @@ require_relative "../base_client"
 module LlmGateway
   module Clients
     class Groq < BaseClient
-      def initialize(model_key: "openai/gpt-oss-20b", api_key: ENV["GROQ_API_KEY"])
+      def initialize(model_key: "openai/gpt-oss-120b", api_key: ENV["GROQ_API_KEY"])
         @base_endpoint = "https://api.groq.com/openai/v1"
         super(model_key: model_key, api_key: api_key)
       end
@@ -21,6 +21,18 @@ module LlmGateway
         post("chat/completions", body)
       end
 
+      def stream(messages, tools: nil, system: [], **options, &block)
+        body = {
+          model: model_key,
+          messages: system + messages,
+          tools: tools,
+          stream_options: { include_usage: true }
+        }
+        body.merge!(options)
+
+        post_stream("chat/completions", body, &block)
+      end
+
       private
 
       def build_headers

data/lib/llm_gateway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmGateway
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/llm_gateway.rb

@@ -21,17 +21,17 @@ require_relative "llm_gateway/clients/groq"
 require_relative "llm_gateway/adapters/option_mapper"
 require_relative "llm_gateway/adapters/anthropic_option_mapper"
 require_relative "llm_gateway/adapters/structs"
+require_relative "llm_gateway/adapters/stream_mapper"
 
 require_relative "llm_gateway/adapters/anthropic/input_mapper"
 require_relative "llm_gateway/adapters/anthropic/output_mapper"
 require_relative "llm_gateway/adapters/openai/file_output_mapper"
 require_relative "llm_gateway/adapters/openai/prompt_cache_option_mapper"
 require_relative "llm_gateway/adapters/openai/chat_completions/input_mapper"
-require_relative "llm_gateway/adapters/openai/chat_completions/output_mapper"
 require_relative "llm_gateway/adapters/openai/chat_completions/option_mapper"
+require_relative "llm_gateway/adapters/openai/chat_completions/stream_mapper"
 require_relative "llm_gateway/adapters/openai/file_output_mapper"
 require_relative "llm_gateway/adapters/openai/responses/input_mapper"
-require_relative "llm_gateway/adapters/openai/responses/output_mapper"
 require_relative "llm_gateway/adapters/openai/responses/option_mapper"
 
 # Load adapter classes
@@ -48,10 +48,6 @@ require_relative "llm_gateway/provider_registry"
 module LlmGateway
   class Error < StandardError; end
 
-  # Direction constants for message mappers
-  DIRECTION_IN = :in
-  DIRECTION_OUT = :out
-
   # Backward-compatible aliases for renamed clients/adapters
   module Clients
     Claude = Anthropic
@@ -63,9 +59,7 @@ module LlmGateway
       Client = LlmGateway::Clients::Anthropic
       MessagesAdapter = LlmGateway::Adapters::Anthropic::MessagesAdapter
       InputMapper = LlmGateway::Adapters::Anthropic::InputMapper
-      OutputMapper = LlmGateway::Adapters::Anthropic::OutputMapper
       StreamMapper = LlmGateway::Adapters::Anthropic::StreamMapper
-      BidirectionalMessageMapper = LlmGateway::Adapters::Anthropic::BidirectionalMessageMapper
       FileOutputMapper = LlmGateway::Adapters::Anthropic::FileOutputMapper
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-17 00:00:00.000000000 Z
+date: 2026-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -33,6 +33,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".pi/skills/live-provider-testing/SKILL.md"
+- ".pi/skills/options-development/SKILL.md"
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -43,37 +45,34 @@ files:
 - lib/llm_gateway.rb
 - lib/llm_gateway/adapters/adapter.rb
 - lib/llm_gateway/adapters/anthropic/acts_like_messages.rb
-- lib/llm_gateway/adapters/anthropic/bidirectional_message_mapper.rb
 - lib/llm_gateway/adapters/anthropic/input_mapper.rb
 - lib/llm_gateway/adapters/anthropic/messages_adapter.rb
 - lib/llm_gateway/adapters/anthropic/output_mapper.rb
 - lib/llm_gateway/adapters/anthropic/stream_mapper.rb
 - lib/llm_gateway/adapters/anthropic_option_mapper.rb
 - lib/llm_gateway/adapters/groq/chat_completions_adapter.rb
+- lib/llm_gateway/adapters/groq/input_mapper.rb
 - lib/llm_gateway/adapters/groq/option_mapper.rb
 - lib/llm_gateway/adapters/input_message_sanitizer.rb
+- lib/llm_gateway/adapters/normalized_stream_accumulator.rb
 - lib/llm_gateway/adapters/openai/acts_like_chat_completions.rb
 - lib/llm_gateway/adapters/openai/acts_like_responses.rb
-- lib/llm_gateway/adapters/openai/chat_completions/bidirectional_message_mapper.rb
 - lib/llm_gateway/adapters/openai/chat_completions/input_mapper.rb
 - lib/llm_gateway/adapters/openai/chat_completions/input_message_sanitizer.rb
 - lib/llm_gateway/adapters/openai/chat_completions/option_mapper.rb
-- lib/llm_gateway/adapters/openai/chat_completions/output_mapper.rb
 - lib/llm_gateway/adapters/openai/chat_completions/stream_mapper.rb
 - lib/llm_gateway/adapters/openai/chat_completions_adapter.rb
 - lib/llm_gateway/adapters/openai/file_output_mapper.rb
 - lib/llm_gateway/adapters/openai/prompt_cache_option_mapper.rb
-- lib/llm_gateway/adapters/openai/responses/bidirectional_message_mapper.rb
 - lib/llm_gateway/adapters/openai/responses/input_mapper.rb
 - lib/llm_gateway/adapters/openai/responses/option_mapper.rb
-- lib/llm_gateway/adapters/openai/responses/output_mapper.rb
 - lib/llm_gateway/adapters/openai/responses/stream_mapper.rb
 - lib/llm_gateway/adapters/openai/responses_adapter.rb
 - lib/llm_gateway/adapters/openai_codex/input_mapper.rb
 - lib/llm_gateway/adapters/openai_codex/option_mapper.rb
 - lib/llm_gateway/adapters/openai_codex/responses_adapter.rb
 - lib/llm_gateway/adapters/option_mapper.rb
-- lib/llm_gateway/adapters/stream_accumulator.rb
+- lib/llm_gateway/adapters/stream_mapper.rb
 - lib/llm_gateway/adapters/structs.rb
 - lib/llm_gateway/base_client.rb
 - lib/llm_gateway/client.rb
@@ -92,8 +91,6 @@ files:
 - lib/llm_gateway/version.rb
 - scripts/create_anthropic_credentials.rb
 - scripts/create_openai_codex_credentials.rb
-- scripts/generate_handoff_live_fixture.rb
-- scripts/generate_handoff_media_fixture.rb
 - sig/llm_gateway.rbs
 homepage: https://github.com/Hyper-Unearthing/llm_gateway
 licenses:

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Anthropic
-      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 "tool_result"
-            map_tool_result_content(content)
-          when "thinking", "reasoning"
-            map_reasoning_content(content)
-          else
-            content
-          end
-        end
-
-        private
-
-        def map_text_content(content)
-          result = {
-            type: "text",
-            text: content[:text]
-          }
-          result[:cache_control] = content[:cache_control] if content[:cache_control]
-          result
-        end
-
-        def map_file_content(content)
-          {
-            type: "document",
-            source: {
-              data: content[:data],
-              type: "text",
-              media_type: content[:media_type]
-            }
-          }
-        end
-
-        def map_image_content(content)
-          {
-            type: "image",
-            source: {
-              data: content[:data],
-              type: "base64",
-              media_type: content[:media_type]
-            }
-          }
-        end
-
-        def map_tool_use_content(content)
-          {
-            type: "tool_use",
-            id: content[:id],
-            name: content[:name],
-            input: content[:input]
-          }
-        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
-
-          {
-            type: "tool_result",
-            tool_use_id: content[:tool_use_id],
-            content: mapped_content
-          }
-        end
-
-        def map_reasoning_content(content)
-          if direction == LlmGateway::DIRECTION_IN
-            result = {
-              type: "thinking",
-              thinking: content[:reasoning]
-            }
-            result[:signature] = content[:signature] unless content[:signature].nil?
-            result
-          else
-            {
-              type: "reasoning",
-              reasoning: content[:thinking] || content[:reasoning],
-              signature: content[:signature]
-            }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-# 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/output_mapper.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module OpenAI
-      module ChatCompletions
-        class OutputMapper
-        def self.map(data)
-          {
-            id: data[:id],
-            model: data[:model],
-            usage: data[:usage],
-            choices: map_choices(data[:choices])
-          }
-        end
-
-        private
-
-        def self.map_choices(choices)
-          return [] unless choices
-          message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_OUT)
-
-          choices.map do |choice|
-            message = choice[:message] || {}
-            content_item = message_mapper.map_content(message[:content])
-            tool_calls = message[:tool_calls] ? message[:tool_calls].map { |tool_call| message_mapper.map_content(tool_call) } : []
-
-            # Only include content_item if it has actual text content
-            content_array = []
-            content_array << content_item if LlmGateway::Utils.present?(content_item[:text])
-            content_array += tool_calls
-
-            { role: message[:role], content: content_array }
-          end
-        end
-        end
-      end
-    end
-  end
-end

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

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-
-module LlmGateway
-  module Adapters
-    module OpenAI
-      module Responses
-        class BidirectionalMessageMapper < OpenAI::ChatCompletions::BidirectionalMessageMapper
-          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 "image"
-              map_image_content(content)
-            when "message"
-              map_messages(content)
-            when "output_text"
-              map_output_text_content(content)
-            when "tool_use"
-              map_tool_use_content(content)
-            when "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
-
-        private
-
-          def map_messages(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|
-                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": output
-            }
-          end
-
-          def map_tool_use_content(content)
-            if direction == LlmGateway::DIRECTION_OUT
-              { id: content[:call_id], type: "tool_use", name: content[:name], input: parse_tool_arguments(content[:arguments]) }
-            else
-              { id: content[:id] }
-            end
-          end
-
-          def map_output_text_content(content)
-            {
-              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
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require_relative "bidirectional_message_mapper"
-
-module LlmGateway
-  module Adapters
-    module OpenAI
-      module Responses
-        class OutputMapper
-          def self.map(data)
-            {
-              id: data[:id],
-              model: data[:model],
-              usage: data[:usage],
-              choices: map_choices(data[:output])
-            }
-          end
-
-          private
-
-          def self.map_choices(choices)
-            return [] unless choices
-            message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_OUT)
-            choices.map do |choice|
-              content = if choice[:id].start_with?("fc_")
-                {
-                  id: choice[:id],
-                  role: choice[:role] || "assistant", # tool call doesnt have a role apparently
-                  content: [ message_mapper.map_content(choice) ].flatten
-                }
-              else
-               content = message_mapper.map_content(choice)
-               id = content.delete(:id)
-               {
-                 id: choice[:id] || id,
-                 role: choice[:role],
-                 content: [ content ].flatten
-               }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end