llm_gateway 0.3.0 → 0.4.0

data/scripts/generate_handoff_media_fixture.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "fileutils"
+require_relative "../lib/llm_gateway"
+require_relative "../test/utils/readfile_tool_helper"
+
+class HandoffMediaLiveFixtureGenerator
+  include ReadfileToolHelper
+
+  PAIRS = [
+    { provider: "openai_apikey_completions", model: "gpt-5.1" },
+    { provider: "openai_apikey_responses", model: "gpt-5.4" },
+    { provider: "openai_oauth_codex", model: "gpt-5.4" },
+    { provider: "anthropic_apikey_messages", model: "claude-sonnet-4-20250514" }
+  ].freeze
+
+  FIXTURE_PATH = File.expand_path("../test/fixtures/handoff_media_live_fixture.json", __dir__)
+
+  def run
+    flat_transcript = []
+    skipped = []
+
+    PAIRS.each do |pair|
+      begin
+        adapter = load_provider(provider: pair[:provider], model: pair[:model])
+        mini_context = generate_mini_context(adapter)
+        flat_transcript.concat(mini_context.map(&:to_h))
+        puts "[ok] #{pair[:provider]} / #{pair[:model]}"
+      rescue StandardError => e
+        skipped << pair.merge(error: e.message)
+        puts "[skip] #{pair[:provider]} / #{pair[:model]} -> #{e.message}"
+      ensure
+        LlmGateway.reset_configuration!
+      end
+    end
+
+    FileUtils.mkdir_p(File.dirname(FIXTURE_PATH))
+    File.write(FIXTURE_PATH, JSON.pretty_generate(flat_transcript) + "\n")
+
+    puts "\nWrote fixture: #{FIXTURE_PATH}"
+    puts "Messages: #{flat_transcript.length}"
+    puts "Skipped pairs: #{skipped.length}"
+  end
+
+  private
+
+  def generate_mini_context(adapter)
+    transcript = [
+      {
+        role: "user",
+        content: "Use the readfile tool with path test/fixtures/red-circle.png and tell me what is in the image."
+      }
+    ]
+
+    first = adapter.stream(transcript, tools: [ readfile_tool ], reasoning: "high")
+    raise first.error_message if first.stop_reason == "error"
+
+    transcript << first
+
+    tool_call = first.content.find { |block| block.type == "tool_use" && block.name == "readfile" }
+    raise "model did not call readfile" unless tool_call
+
+    transcript << {
+      role: "developer",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: tool_call.id,
+          content: evaluate_readfile(tool_call.input)
+        }
+      ]
+    }
+
+    second = adapter.stream(
+      transcript.map { |m| m.respond_to?(:to_h) ? m.to_h : m },
+      tools: [ readfile_tool ],
+      reasoning: "high"
+    )
+    raise second.error_message if second.stop_reason == "error"
+
+    transcript << second
+    transcript
+  end
+
+  def load_provider(provider:, model:)
+    config = {
+      "provider" => provider,
+      "model_key" => model
+    }
+
+    case provider
+    when "openai_apikey_completions", "openai_apikey_responses"
+      api_key = ENV["OPENAI_API_KEY"].to_s
+      raise "missing OPENAI_API_KEY" if api_key.empty?
+
+      config["api_key"] = api_key
+    when "anthropic_apikey_messages"
+      api_key = ENV["ANTHROPIC_API_KEY"].to_s
+      raise "missing ANTHROPIC_API_KEY" if api_key.empty?
+
+      config["api_key"] = api_key
+    when "openai_oauth_codex"
+      creds = load_auth_credentials("openai")
+      config["api_key"] = oauth_access_token_for("openai")
+      config["account_id"] = creds["account_id"] if creds["account_id"]
+    else
+      raise ArgumentError, "Unsupported provider: #{provider}"
+    end
+
+    LlmGateway.build_provider(config)
+  end
+
+  def auth_file_path
+    File.expand_path(ENV.fetch("LLM_GATEWAY_AUTH_FILE", "~/.config/llm_gateway/auth.json"))
+  end
+
+  def load_auth_credentials(provider)
+    path = auth_file_path
+    raise "missing auth file at #{path}" unless File.exist?(path)
+
+    auth = JSON.parse(File.read(path))
+    creds = auth[provider]
+    raise "missing #{provider} credentials in #{path}" unless creds
+
+    creds
+  end
+
+  def persist_auth_credentials(provider, attributes)
+    path = auth_file_path
+    FileUtils.mkdir_p(File.dirname(path))
+
+    auth = File.exist?(path) ? JSON.parse(File.read(path)) : {}
+    auth[provider] ||= {}
+    auth[provider].merge!(attributes)
+
+    File.write(path, JSON.pretty_generate(auth) + "\n")
+  end
+
+  def oauth_access_token_for(provider)
+    creds = load_auth_credentials(provider)
+
+    case provider
+    when "openai"
+      token = LlmGateway::Clients::OpenAi.new.get_oauth_access_token(
+        access_token: creds["access_token"],
+        refresh_token: creds["refresh_token"],
+        expires_at: creds["expires_at"],
+        account_id: creds["account_id"]
+      ) do |access_token, refresh_token, expires_at|
+        persist_auth_credentials("openai", {
+          "access_token" => access_token,
+          "refresh_token" => refresh_token,
+          "expires_at" => expires_at&.iso8601
+        })
+      end
+
+      persist_auth_credentials("openai", { "access_token" => token }) if token != creds["access_token"]
+      token
+    else
+      raise ArgumentError, "Unsupported OAuth provider: #{provider}"
+    end
+  end
+end
+
+HandoffMediaLiveFixtureGenerator.new.run

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-19 00:00:00.000000000 Z
-dependencies: []
+date: 2026-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: LlmGateway provides a consistent Ruby interface for multiple LLM providers
   including Claude, OpenAI, and Groq. Features include unified response formatting,
   error handling, and fluent data mapping.
@@ -25,39 +39,61 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- docs/migration-guide.md
 - lib/llm_gateway.rb
-- lib/llm_gateway/adapters/claude/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/claude/client.rb
-- lib/llm_gateway/adapters/claude/input_mapper.rb
-- lib/llm_gateway/adapters/claude/output_mapper.rb
-- lib/llm_gateway/adapters/groq/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/groq/client.rb
-- lib/llm_gateway/adapters/groq/input_mapper.rb
-- lib/llm_gateway/adapters/groq/output_mapper.rb
-- lib/llm_gateway/adapters/open_ai/chat_completions/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/open_ai/chat_completions/input_mapper.rb
-- lib/llm_gateway/adapters/open_ai/chat_completions/output_mapper.rb
-- lib/llm_gateway/adapters/open_ai/client.rb
-- lib/llm_gateway/adapters/open_ai/file_output_mapper.rb
-- lib/llm_gateway/adapters/open_ai/responses/bidirectional_message_mapper.rb
-- lib/llm_gateway/adapters/open_ai/responses/input_mapper.rb
-- lib/llm_gateway/adapters/open_ai/responses/output_mapper.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/option_mapper.rb
+- lib/llm_gateway/adapters/input_message_sanitizer.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/structs.rb
 - lib/llm_gateway/base_client.rb
 - lib/llm_gateway/client.rb
+- lib/llm_gateway/clients/anthropic.rb
+- lib/llm_gateway/clients/claude_code/oauth_flow.rb
+- lib/llm_gateway/clients/claude_code/token_manager.rb
+- lib/llm_gateway/clients/groq.rb
+- lib/llm_gateway/clients/openai.rb
+- lib/llm_gateway/clients/openai_codex/oauth_flow.rb
+- lib/llm_gateway/clients/openai_codex/token_manager.rb
 - lib/llm_gateway/errors.rb
 - lib/llm_gateway/prompt.rb
+- lib/llm_gateway/provider_registry.rb
 - lib/llm_gateway/tool.rb
 - lib/llm_gateway/utils.rb
 - lib/llm_gateway/version.rb
-- sample/claude_code_clone/agent.rb
-- sample/claude_code_clone/claude_code_clone.rb
-- sample/claude_code_clone/prompt.rb
-- sample/claude_code_clone/run.rb
-- sample/claude_code_clone/tools/bash_tool.rb
-- sample/claude_code_clone/tools/edit_tool.rb
-- sample/claude_code_clone/tools/grep_tool.rb
-- sample/claude_code_clone/tools/read_tool.rb
-- sample/claude_code_clone/tools/todowrite_tool.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/claude/client.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module Claude
-      class Client < BaseClient
-        def initialize(model_key: "claude-3-7-sonnet-20250219", api_key: ENV["ANTHROPIC_API_KEY"])
-          @base_endpoint = "https://api.anthropic.com/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            max_tokens: max_completion_tokens,
-            messages: messages
-          }
-
-          body.merge!(tools: tools) if LlmGateway::Utils.present?(tools)
-          body.merge!(system: system) if LlmGateway::Utils.present?(system)
-
-          post("messages", body)
-        end
-
-        def download_file(file_id)
-          get("files/#{file_id}/content")
-        end
-
-        def upload_file(filename, content, mime_type = "application/octet-stream")
-          post_file("files", content, filename, mime_type: mime_type)
-        end
-
-        private
-
-        def build_headers
-          {
-            "anthropic-version" => "2023-06-01",
-            "content-type" => "application/json",
-            "x-api-key" => api_key,
-            "anthropic-beta" => "code-execution-2025-05-22,files-api-2025-04-14"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          case response.code.to_i
-          when 400
-            if error["message"]&.start_with?("prompt is too long")
-              raise Errors::PromptTooLong.new(error["message"], error["type"])
-            end
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error["type"])
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../open_ai/chat_completions/bidirectional_message_mapper"
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class BidirectionalMessageMapper < OpenAi::ChatCompletions::BidirectionalMessageMapper
-        private
-
-        def map_file_content(content)
-          # Groq doesn't support files, return as text
-          content[:text] || "[File: #{content[:name]}]"
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class Client < BaseClient
-        def initialize(model_key: "gemma2-9b-it", api_key: ENV["GROQ_API_KEY"])
-          @base_endpoint = "https://api.groq.com/openai/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            messages: system + messages,
-            temperature: 0,
-            max_completion_tokens: max_completion_tokens,
-            response_format: response_format,
-            tools: tools
-          }
-
-          post("chat/completions", body)
-        end
-
-        private
-
-        def build_headers
-          {
-            "content-type" => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          # Groq likely uses 'code' like OpenAI since it's OpenAI-compatible
-          error_code = error["code"]
-
-          case response.code.to_i
-
-          when 413
-            if error["message"]&.start_with?("Request too large")
-              raise Errors::PromptTooLong.new(error["message"], error["type"])
-            end
-          when 429
-            raise Errors::RateLimitError.new(error["type"], error_code) if error_code == "rate_limit_exceeded"
-
-            raise Errors::OverloadError.new(error["message"], error_code)
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error_code)
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "bidirectional_message_mapper"
-require_relative "../open_ai/chat_completions/input_mapper"
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class InputMapper < OpenAi::ChatCompletions::InputMapper
-        private
-
-        def self.map_system(system)
-          system
-        end
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class OutputMapper < LlmGateway::Adapters::OpenAi::ChatCompletions::OutputMapper
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/open_ai/client.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      class Client < BaseClient
-        def initialize(model_key: "gpt-4o", api_key: ENV["OPENAI_API_KEY"])
-          @base_endpoint = "https://api.openai.com/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            messages: system + messages,
-            max_completion_tokens: max_completion_tokens
-          }
-          body[:tools] = tools if tools
-
-          post("chat/completions", body)
-        end
-
-        def responses(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-            body = {
-              model: model_key,
-              max_output_tokens: max_completion_tokens,
-              input: messages.flatten
-            }
-            body[:instructions] = system[0][:content] if system.any?
-            body[:tools] = tools if tools
-            result = post("responses", body)
-            result
-        end
-
-
-        def download_file(file_id)
-          get("files/#{file_id}/content")
-        end
-
-        def generate_embeddings(input)
-          body = {
-            input:,
-            model: model_key
-          }
-          post("embeddings", body)
-        end
-
-        def upload_file(filename, content, mime_type = "application/octet-stream", purpose: "user_data")
-          post_file("files", content, filename, purpose: purpose, mime_type: mime_type)
-        end
-
-        private
-
-        def build_headers
-          {
-            "content-type" => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          # OpenAI uses 'code' instead of 'type' for error codes
-          error_code = error["code"]
-
-          case response.code.to_i
-          when 429
-            raise Errors::RateLimitError.new(error["message"], error_code)
-          when 503
-            raise Errors::OverloadError.new(error["message"], error_code)
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error_code)
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# 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
-
-            tools.map do |tool|
-              {
-                type: "function",
-                name: tool[:name],
-                description: tool[:description],
-                parameters: tool[:input_schema]
-              }
-            end
-          end
-
-          def self.map_messages(messages)
-            return messages unless messages
-            mapper = message_mapper
-
-            # First map messages like Claude
-            messages.map do |msg|
-              if msg[:id]
-                msg = msg.merge(role: "assistant")
-                msg.slice(:id)
-              else
-                content = if msg[:content].is_a?(Array)
-                    msg[:content].map do |content|
-                      mapper.map_content(content)
-                    end
-                elsif msg[:id]
-                  mapper.map_content(msg)
-                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
-        end
-      end
-    end
-  end
-end

data/sample/claude_code_clone/agent.rb

@@ -1,65 +0,0 @@
-class Agent
-  def initialize(prompt_class, model, api_key)
-    @prompt_class = prompt_class
-    @model = model
-    @api_key = api_key
-    @transcript = []
-  end
-
-  def run(user_input, &block)
-    @transcript << { role: 'user', content: [ { type: 'text', text: user_input } ] }
-
-    begin
-      prompt = @prompt_class.new(@model, @transcript, @api_key)
-      result = prompt.post
-      process_response(result[:choices][0][:content], &block)
-    rescue => e
-      yield({ type: 'error', message: e.message }) if block_given?
-      raise e
-    end
-  end
-
-  private
-
-  def process_response(response, &block)
-    @transcript << { role: 'assistant', content: response }
-
-    response.each do |message|
-      yield(message) if block_given?
-
-      if message[:type] == 'text'
-        # Text response processed
-      elsif message[:type] == 'tool_use'
-        result = handle_tool_use(message)
-
-        tool_result = {
-          type: 'tool_result',
-          tool_use_id: message[:id],
-          content: result
-        }
-        @transcript << { role: 'user', content: [ tool_result ] }
-
-        yield(tool_result) if block_given?
-
-        follow_up_prompt = @prompt_class.new(@model, @transcript, @api_key)
-        follow_up = follow_up_prompt.post
-
-        process_response(follow_up[:choices][0][:content], &block) if follow_up[:choices][0][:content]
-      end
-    end
-
-    response
-  end
-
-  def handle_tool_use(message)
-    tool_class = @prompt_class.find_tool(message[:name])
-    if tool_class
-      tool = tool_class.new
-      tool.execute(message[:input])
-    else
-      "Unknown tool: #{message[:name]}"
-    end
-  rescue StandardError => e
-    "Error executing tool: #{e.message}"
-  end
-end