llm_gateway 0.3.0 → 0.4.0

data/lib/llm_gateway.rb

@@ -8,20 +8,42 @@ require_relative "llm_gateway/client"
 require_relative "llm_gateway/prompt"
 require_relative "llm_gateway/tool"
 
-# Load adapters - order matters for inheritance
-require_relative "llm_gateway/adapters/claude/client"
-require_relative "llm_gateway/adapters/claude/input_mapper"
-require_relative "llm_gateway/adapters/claude/output_mapper"
-require_relative "llm_gateway/adapters/open_ai/client"
-require_relative "llm_gateway/adapters/open_ai/file_output_mapper"
-require_relative "llm_gateway/adapters/open_ai/chat_completions/input_mapper"
-require_relative "llm_gateway/adapters/open_ai/chat_completions/output_mapper"
-require_relative "llm_gateway/adapters/groq/client"
-require_relative "llm_gateway/adapters/groq/input_mapper"
-require_relative "llm_gateway/adapters/groq/output_mapper"
-require_relative "llm_gateway/adapters/open_ai/file_output_mapper"
-require_relative "llm_gateway/adapters/open_ai/responses/input_mapper"
-require_relative "llm_gateway/adapters/open_ai/responses/output_mapper"
+# Load clients - order matters for inheritance
+require_relative "llm_gateway/clients/anthropic"
+require_relative "llm_gateway/clients/claude_code/oauth_flow"
+require_relative "llm_gateway/clients/claude_code/token_manager"
+require_relative "llm_gateway/clients/openai"
+require_relative "llm_gateway/clients/openai_codex/oauth_flow"
+require_relative "llm_gateway/clients/openai_codex/token_manager"
+require_relative "llm_gateway/clients/groq"
+
+# Load adapters
+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/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/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
+require_relative "llm_gateway/adapters/adapter"
+require_relative "llm_gateway/adapters/anthropic/messages_adapter"
+require_relative "llm_gateway/adapters/openai/chat_completions_adapter"
+require_relative "llm_gateway/adapters/openai/responses_adapter"
+require_relative "llm_gateway/adapters/openai_codex/responses_adapter"
+require_relative "llm_gateway/adapters/groq/chat_completions_adapter"
+
+# Load provider registry
+require_relative "llm_gateway/provider_registry"
 
 module LlmGateway
   class Error < StandardError; end
@@ -29,4 +51,133 @@ module LlmGateway
   # Direction constants for message mappers
   DIRECTION_IN = :in
   DIRECTION_OUT = :out
+
+  # Backward-compatible aliases for renamed clients/adapters
+  module Clients
+    Claude = Anthropic
+    OpenAi = OpenAI
+  end
+
+  module Adapters
+    module Claude
+      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
+
+    module Anthropic
+      Client = LlmGateway::Clients::Anthropic
+    end
+
+    module OpenAI
+      Client = LlmGateway::Clients::OpenAI
+    end
+
+    module OpenAi
+      Client = LlmGateway::Clients::OpenAI
+      ChatCompletionsAdapter = LlmGateway::Adapters::OpenAI::ChatCompletionsAdapter
+      ResponsesAdapter = LlmGateway::Adapters::OpenAI::ResponsesAdapter
+      PromptCacheOptionMapper = LlmGateway::Adapters::OpenAI::PromptCacheOptionMapper
+      FileOutputMapper = LlmGateway::Adapters::OpenAI::FileOutputMapper
+      ChatCompletions = LlmGateway::Adapters::OpenAI::ChatCompletions
+      Responses = LlmGateway::Adapters::OpenAI::Responses
+    end
+
+    module OpenAICodex
+      Client = LlmGateway::Clients::OpenAI
+    end
+
+    module OpenAiCodex
+      Client = LlmGateway::Clients::OpenAI
+      ResponsesAdapter = LlmGateway::Adapters::OpenAICodex::ResponsesAdapter
+      InputMapper = LlmGateway::Adapters::OpenAICodex::InputMapper
+      OptionMapper = LlmGateway::Adapters::OpenAICodex::OptionMapper
+    end
+
+    module Groq
+      Client = LlmGateway::Clients::Groq
+    end
+  end
+
+  def self.build_provider(config)
+    config = config.transform_keys(&:to_sym)
+    provider_name = config.delete(:provider)
+    entry = ProviderRegistry.resolve(provider_name)
+
+    client = entry[:client].new(**config)
+    entry[:adapter].new(client)
+  end
+
+  def self.configure(configs)
+    @configured_clients ||= {}
+
+    configs.each do |entry|
+      name = entry[:name] || entry["name"]
+      config = entry[:config] || entry["config"]
+
+      raise ArgumentError, "Each config entry must have a :name" unless name
+
+      client = build_provider(config)
+      @configured_clients[name.to_sym] = client
+
+      define_singleton_method(name.to_sym) { @configured_clients[name.to_sym] }
+    end
+  end
+
+  def self.configured_clients
+    @configured_clients ||= {}
+  end
+
+  def self.reset_configuration!
+    @configured_clients&.each_key do |name|
+      singleton_class.remove_method(name) if respond_to?(name)
+    end
+    @configured_clients = {}
+  end
+
+  # Register built-in providers (canonical keys)
+  ProviderRegistry.register("anthropic_messages",
+    client: Clients::Anthropic,
+    adapter: Adapters::Anthropic::MessagesAdapter)
+
+  ProviderRegistry.register("openai_completions",
+    client: Clients::OpenAI,
+    adapter: Adapters::OpenAI::ChatCompletionsAdapter)
+
+  ProviderRegistry.register("openai_responses",
+    client: Clients::OpenAI,
+    adapter: Adapters::OpenAI::ResponsesAdapter)
+
+  ProviderRegistry.register("groq_completions",
+    client: Clients::Groq,
+    adapter: Adapters::Groq::ChatCompletionsAdapter)
+
+  ProviderRegistry.register("openai_codex",
+    client: Clients::OpenAI,
+    adapter: Adapters::OpenAICodex::ResponsesAdapter)
+
+  # Backward-compatible aliases (deprecated)
+  ProviderRegistry.register("anthropic_apikey_messages",
+    client: Clients::Anthropic,
+    adapter: Adapters::Anthropic::MessagesAdapter)
+
+  ProviderRegistry.register("openai_apikey_completions",
+    client: Clients::OpenAI,
+    adapter: Adapters::OpenAI::ChatCompletionsAdapter)
+
+  ProviderRegistry.register("openai_apikey_responses",
+    client: Clients::OpenAI,
+    adapter: Adapters::OpenAI::ResponsesAdapter)
+
+  ProviderRegistry.register("groq_apikey_completions",
+    client: Clients::Groq,
+    adapter: Adapters::Groq::ChatCompletionsAdapter)
+
+  ProviderRegistry.register("openai_oauth_codex",
+    client: Clients::OpenAI,
+    adapter: Adapters::OpenAICodex::ResponsesAdapter)
 end

data/scripts/create_anthropic_credentials.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "fileutils"
+require_relative "../lib/llm_gateway"
+
+module Scripts
+  class CreateAnthropicCredentials
+    def initialize(argv)
+      @options = {
+        client_id: LlmGateway::Clients::ClaudeCode::OAuthFlow::CLIENT_ID,
+        scopes: LlmGateway::Clients::ClaudeCode::OAuthFlow::DEFAULT_SCOPES,
+        output: File.expand_path(ENV.fetch("LLM_GATEWAY_AUTH_FILE", "~/.config/llm_gateway/auth.json"))
+      }
+      parse_options(argv)
+    end
+
+    def run
+      flow = LlmGateway::Clients::ClaudeCode::OAuthFlow.new(
+        client_id: @options[:client_id],
+        scopes: @options[:scopes]
+      )
+
+      auth = flow.start
+
+      puts "Anthropic OAuth setup"
+      puts "Redirect URI: #{flow.redirect_uri}"
+      puts ""
+      puts "Open this URL in your browser:"
+      puts auth[:authorization_url]
+      puts ""
+      puts "After authenticating, paste either:"
+      puts "- the full callback URL"
+      puts "- or the legacy code#state value"
+      print "> "
+
+      callback_value = $stdin.gets.to_s.strip
+      tokens = flow.exchange_code(callback_value, auth[:code_verifier], state: auth[:state])
+
+      credentials = {
+        client_id: flow.client_id,
+        access_token: tokens[:access_token],
+        refresh_token: tokens[:refresh_token],
+        expires_at: tokens[:expires_at]&.iso8601
+      }
+
+      persist_credentials("anthropic", credentials)
+
+      puts "Credentials:"
+      puts JSON.pretty_generate(credentials)
+      puts ""
+      puts "Environment exports:"
+      puts "export ANTHROPIC_ACCESS_TOKEN=#{shell_escape(tokens[:access_token])}"
+      puts "export ANTHROPIC_REFRESH_TOKEN=#{shell_escape(tokens[:refresh_token])}"
+      puts "export ANTHROPIC_EXPIRES_AT=#{shell_escape(tokens[:expires_at]&.iso8601.to_s)}"
+    rescue Interrupt
+      warn "Aborted."
+      exit 1
+    end
+
+    private
+
+    def parse_options(argv)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ruby scripts/create_anthropic_credentials.rb [options]"
+
+        opts.on("--client-id ID", "Anthropic OAuth client id") do |value|
+          @options[:client_id] = value
+        end
+
+        opts.on("--scopes SCOPES", "OAuth scopes") do |value|
+          @options[:scopes] = value
+        end
+
+        opts.on("--output PATH", "Write credentials JSON to PATH") do |value|
+          @options[:output] = value
+        end
+      end.parse!(argv)
+    end
+
+    def persist_credentials(provider, credentials)
+      output_path = File.expand_path(@options[:output])
+      FileUtils.mkdir_p(File.dirname(output_path))
+
+      existing = if File.exist?(output_path)
+        JSON.parse(File.read(output_path))
+      else
+        {}
+      end
+
+      existing[provider] = credentials
+      File.write(output_path, JSON.pretty_generate(existing) + "\n")
+      puts "Credentials written to #{output_path}"
+    end
+
+    def shell_escape(value)
+      return "''" if value.nil? || value.empty?
+
+      "'#{value.to_s.gsub("'", %q('\''))}'"
+    end
+  end
+end
+
+Scripts::CreateAnthropicCredentials.new(ARGV).run

data/scripts/create_openai_codex_credentials.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "fileutils"
+require_relative "../lib/llm_gateway"
+
+module Scripts
+  class CreateOpenAiCodexCredentials
+    def initialize(argv)
+      @options = {
+        client_id: LlmGateway::Clients::OpenAi::OAuthFlow::CLIENT_ID,
+        redirect_uri: LlmGateway::Clients::OpenAi::OAuthFlow::REDIRECT_URI,
+        scope: LlmGateway::Clients::OpenAi::OAuthFlow::SCOPE,
+        output: File.expand_path(ENV.fetch("LLM_GATEWAY_AUTH_FILE", "~/.config/llm_gateway/auth.json"))
+      }
+      parse_options(argv)
+    end
+
+    def run
+      flow = LlmGateway::Clients::OpenAi::OAuthFlow.new(
+        client_id: @options[:client_id],
+        redirect_uri: @options[:redirect_uri],
+        scope: @options[:scope]
+      )
+
+      auth = flow.start
+
+      puts "OpenAI Codex OAuth setup"
+      puts "Redirect URI: #{flow.redirect_uri}"
+      puts ""
+      puts "Open this URL in your browser:"
+      puts auth[:authorization_url]
+      puts ""
+      puts "After authenticating, the browser will redirect to localhost (the page won't load)."
+      puts "Paste either:"
+      puts "  - the full callback URL  (http://localhost:1455/auth/callback?code=...)"
+      puts "  - or just the code"
+      print "> "
+
+      callback_value = $stdin.gets.to_s.strip
+      tokens = flow.exchange_code(callback_value, auth[:code_verifier], expected_state: auth[:state])
+
+      credentials = {
+        client_id: flow.client_id,
+        account_id: tokens[:account_id],
+        access_token: tokens[:access_token],
+        refresh_token: tokens[:refresh_token],
+        expires_at: tokens[:expires_at]&.iso8601
+      }
+
+      persist_credentials("openai", credentials)
+
+      puts ""
+      puts "Credentials:"
+      puts JSON.pretty_generate(credentials)
+      puts ""
+      puts "Environment exports:"
+      puts "export OPENAI_CODEX_ACCOUNT_ID=#{shell_escape(tokens[:account_id].to_s)}"
+      puts "export OPENAI_CODEX_ACCESS_TOKEN=#{shell_escape(tokens[:access_token])}"
+      puts "export OPENAI_CODEX_REFRESH_TOKEN=#{shell_escape(tokens[:refresh_token])}"
+      puts "export OPENAI_CODEX_EXPIRES_AT=#{shell_escape(tokens[:expires_at]&.iso8601.to_s)}"
+    rescue Interrupt
+      warn "Aborted."
+      exit 1
+    end
+
+    private
+
+    def parse_options(argv)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: ruby scripts/create_openai_codex_credentials.rb [options]"
+
+        opts.on("--client-id ID", "OpenAI OAuth client id") do |value|
+          @options[:client_id] = value
+        end
+
+        opts.on("--redirect-uri URI", "OAuth redirect URI") do |value|
+          @options[:redirect_uri] = value
+        end
+
+        opts.on("--scope SCOPE", "OAuth scopes (space-separated)") do |value|
+          @options[:scope] = value
+        end
+
+        opts.on("--output PATH", "Write credentials JSON to PATH") do |value|
+          @options[:output] = value
+        end
+      end.parse!(argv)
+    end
+
+    def persist_credentials(provider, credentials)
+      output_path = File.expand_path(@options[:output])
+      FileUtils.mkdir_p(File.dirname(output_path))
+
+      existing = if File.exist?(output_path)
+        JSON.parse(File.read(output_path))
+      else
+        {}
+      end
+
+      existing[provider] = credentials
+      File.write(output_path, JSON.pretty_generate(existing) + "\n")
+      puts "Credentials written to #{output_path}"
+    end
+
+    def shell_escape(value)
+      return "''" if value.nil? || value.empty?
+
+      "'#{value.to_s.gsub("'", %q('\''))}'"
+    end
+  end
+end
+
+Scripts::CreateOpenAiCodexCredentials.new(ARGV).run

data/scripts/generate_handoff_live_fixture.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "fileutils"
+require 'debug'
+require_relative "../lib/llm_gateway"
+require_relative "../test/utils/calculator_tool_helper"
+
+class HandoffLiveFixtureGenerator
+  include CalculatorToolHelper
+
+  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_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: "Think hard about this, then use the math_operation tool to double 21 by multiplying 21 and 2. Call the tool."
+      }
+    ]
+
+    first = adapter.stream(transcript, tools: [ math_operation_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 == "math_operation" }
+    raise "model did not call math_operation" unless tool_call
+
+    tool_result = {
+      role: "developer",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: tool_call.id,
+          content: evaluate_math_operation(tool_call.input).to_s
+        }
+      ]
+    }
+    transcript << tool_result
+
+    second = adapter.stream(
+      transcript.map { |m| m.respond_to?(:to_h) ? m.to_h : m },
+      tools: [ math_operation_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
+
+HandoffLiveFixtureGenerator.new.run