llm_gateway 0.3.0 → 0.4.0

data/lib/llm_gateway/client.rb

@@ -2,107 +2,41 @@
 
 module LlmGateway
   class Client
-    def self.provider_configs
-      @provider_configs ||= {
-        anthropic: {
-          input_mapper: LlmGateway::Adapters::Claude::InputMapper,
-          output_mapper: LlmGateway::Adapters::Claude::OutputMapper,
-          client: LlmGateway::Adapters::Claude::Client,
-          file_output_mapper: LlmGateway::Adapters::Claude::FileOutputMapper
-        },
-        openai: {
-          input_mapper: LlmGateway::Adapters::OpenAi::ChatCompletions::InputMapper,
-          output_mapper: LlmGateway::Adapters::OpenAi::ChatCompletions::OutputMapper,
-          client: LlmGateway::Adapters::OpenAi::Client,
-          file_output_mapper: LlmGateway::Adapters::OpenAi::FileOutputMapper
-        },
-        openai_responses: {
-          input_mapper: LlmGateway::Adapters::OpenAi::Responses::InputMapper,
-          output_mapper: LlmGateway::Adapters::OpenAi::Responses::OutputMapper,
-          client: LlmGateway::Adapters::OpenAi::Client,
-          file_output_mapper: LlmGateway::Adapters::OpenAi::FileOutputMapper
-        },
-        groq: {
-          input_mapper: LlmGateway::Adapters::Groq::InputMapper,
-          output_mapper: LlmGateway::Adapters::Groq::OutputMapper,
-          client: LlmGateway::Adapters::Groq::Client,
-          file_output_mapper: nil
-        }
-      }.freeze
-    end
-
-    def self.get_provider_config(provider_id)
-      provider_configs[provider_id.to_sym] || raise(LlmGateway::Errors::UnsupportedProvider, provider_id)
-    end
-
-    def self.chat(model, message, response_format: "text", tools: nil, system: nil, api_key: nil)
-      provider = provider_from_model(model)
-      config = get_provider_config(provider)
-      client_options = { model_key: model }
-      client_options[:api_key] = api_key if api_key
-      client = config[:client].new(**client_options)
-
-      input_mapper = input_mapper_for_client(client)
-      normalized_input = input_mapper.map({
-        messages: normalize_messages(message),
-        response_format: normalize_response_format(response_format),
-        tools: tools,
-        system: normalize_system(system)
-      })
-      result = client.chat(
-        normalized_input[:messages],
-        response_format: normalized_input[:response_format],
-        tools: normalized_input[:tools],
-        system: normalized_input[:system]
-      )
-      result_mapper(client).map(result)
+    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, response_format: "text", tools: nil, system: nil, api_key: nil)
-      provider = provider_from_model(model)
-      config = provider == "openai" ? get_provider_config("openai_responses") : get_provider_config(provider)
-      client_options = { model_key: model }
-      client_options[:api_key] = api_key if api_key
-      client = config[:client].new(**client_options)
-      input_mapper = config[:input_mapper]
-      normalized_input = input_mapper.map({
-        messages: normalize_messages(message),
-        response_format: normalize_response_format(response_format),
-        tools: tools,
-        system: normalize_system(system)
-      })
-      method = provider == "openai" ? "responses" : "chat"
-      result = client.send(method,
-        normalized_input[:messages],
-        response_format: normalized_input[:response_format],
-        tools: normalized_input[:tools],
-        system: normalized_input[:system]
-      )
-      config[:output_mapper].map(result)
+    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")
-      config = get_provider_config(provider)
-      client_options = { model_key: model }
-      client_options[:api_key] = api_key if api_key
-      config[:client].new(**client_options)
+      adapter = LlmGateway.build_provider(
+        provider: provider,
+        api_key: api_key,
+        model_key: model
+      )
+      adapter.client
     end
 
     def self.upload_file(provider, **kwargs)
       api_key = kwargs.delete(:api_key)
-      client = build_client(provider, api_key: api_key)
-      result = client.upload_file(*kwargs.values)
-      config = get_provider_config(provider)
-      config[:file_output_mapper].map(result)
+      adapter = LlmGateway.build_provider(
+        provider: provider,
+        api_key: api_key
+      )
+      adapter.upload_file(**kwargs)
     end
 
     def self.download_file(provider, **kwargs)
       api_key = kwargs.delete(:api_key)
-      client = build_client(provider, api_key: api_key)
-      result = client.download_file(*kwargs.values)
-      config = get_provider_config(provider)
-      config[:file_output_mapper].map(result)
+      adapter = LlmGateway.build_provider(
+        provider: provider,
+        api_key: api_key
+      )
+      adapter.download_file(**kwargs)
     end
 
     def self.provider_from_model(model)
@@ -115,61 +49,43 @@ module LlmGateway
       raise LlmGateway::Errors::UnsupportedModel, model
     end
 
-
-    def self.input_mapper_for_client(client)
-      config = get_provider_config_by_client(client)
-      config[:input_mapper]
-    end
-
-    def self.result_mapper(client)
-      config = get_provider_config_by_client(client)
-      config[:output_mapper]
-    end
-
     def self.provider_id_from_client(client)
       case client
-      when LlmGateway::Adapters::Claude::Client
+      when LlmGateway::Clients::Anthropic
         "anthropic"
-      when LlmGateway::Adapters::OpenAi::Client
+      when LlmGateway::Clients::OpenAI
         "openai"
-      when LlmGateway::Adapters::Groq::Client
+      when LlmGateway::Clients::Groq
         "groq"
       else
-        raise LlmGateway::Errors::UnsupportedProvider, client.class.name
+        client.class.name.downcase
       end
     end
 
-    def self.get_provider_config_by_client(client)
-      provider_id = provider_id_from_client(client)
-      get_provider_config(provider_id)
-    end
+    # --- private helpers ---
 
-    def self.normalize_system(system)
-      if system.nil?
-        []
-      elsif system.is_a?(String)
-        [ { role: "system", content: system } ]
-      elsif system.is_a?(Array)
-        system
-      else
-        raise ArgumentError, "System parameter must be a string or array, got #{system.class}"
-      end
-    end
+    def self.build_adapter_from_model(model, api_key: nil, refresh_token: nil, expires_at: nil, api: nil)
+      provider = provider_from_model(model)
 
-    def self.normalize_messages(message)
-      if message.is_a?(String)
-        [ { 'role': "user", 'content': message } ]
+      if api == "responses"
+        config = {
+          provider: "#{provider}_responses",
+          model_key: model
+        }
+        config[:api_key] = api_key if api_key
+        LlmGateway.build_provider(config)
       else
-        message
+        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
 
-    def self.normalize_response_format(response_format)
-      if response_format.is_a?(String)
-        { type: response_format }
-      else
-        response_format
-      end
-    end
+    private_class_method :build_adapter_from_model
   end
 end

data/lib/llm_gateway/clients/anthropic.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "uri"
+require_relative "../base_client"
+require_relative "claude_code/oauth_flow"
+require_relative "claude_code/token_manager"
+
+module LlmGateway
+  module Clients
+    class Anthropic < BaseClient
+      CLAUDE_CODE_VERSION = "2.1.2"
+
+      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, **kwargs)
+        post("messages", build_body(messages, **kwargs))
+      end
+
+      def stream(messages, **kwargs, &block)
+        post_stream("messages", build_body(messages, **kwargs), &block)
+      end
+
+      def get_oauth_access_token(access_token:, refresh_token:, expires_at:, &block)
+        token_manager = LlmGateway::Clients::ClaudeCode::TokenManager.new(
+          access_token: access_token,
+          refresh_token: refresh_token,
+          expires_at: expires_at
+        )
+        token_manager.on_token_refresh = block if block_given?
+        token_manager.ensure_valid_token
+        token_manager.access_token
+      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_body(messages, tools: nil, system: [], cache_retention: nil, **options)
+        cache_control = anthropic_cache_control_for(cache_retention)
+
+        body = {
+          model: model_key,
+          messages: messages
+        }
+
+        tools = apply_tools_cache_control(tools, cache_retention)
+        body.merge!(tools: tools) if LlmGateway::Utils.present?(tools)
+
+        system = prepend_claude_code_identity(system) if claude_code_oauth_api_key?
+        system = apply_system_cache_control(system, cache_retention)
+
+        body.merge!(system: system) if LlmGateway::Utils.present?(system)
+        body.merge!(cache_control: cache_control) unless cache_control.nil?
+        body.merge!(options)
+        body
+      end
+
+      def apply_system_cache_control(system, cache_retention)
+        return system if system.nil? || system.empty? || !system.is_a?(Array)
+
+        cache_control = anthropic_cache_control_for(cache_retention)
+        return system if cache_control.nil?
+
+        last_index = system.length - 1
+        system.each_with_index.map do |block, index|
+          block = block.dup
+          if index == last_index
+            block[:cache_control] = cache_control
+          else
+            block.delete(:cache_control)
+          end
+          block
+        end
+      end
+
+      def apply_tools_cache_control(tools, cache_retention)
+        return tools if tools.nil? || tools.empty? || !tools.is_a?(Array)
+
+        cache_control = anthropic_cache_control_for(cache_retention)
+        return tools if cache_control.nil?
+
+        last_index = tools.length - 1
+        tools.each_with_index.map do |tool, index|
+          tool = tool.dup
+          if index == last_index
+            tool[:cache_control] = cache_control
+          else
+            tool.delete(:cache_control)
+          end
+          tool
+        end
+      end
+
+      def anthropic_cache_control_for(cache_retention)
+        return nil if cache_retention.nil?
+
+        retention = cache_retention.to_s
+        return nil if retention == "none"
+
+        cache_control = { type: "ephemeral" }
+        cache_control = cache_control.merge(ttl: "1h") if retention == "long" && anthropic_official_api?
+        cache_control
+      end
+
+      def anthropic_official_api?
+        URI(base_endpoint).host == "api.anthropic.com"
+      end
+
+      def build_headers
+        return claude_code_oauth_headers if claude_code_oauth_api_key?
+
+        {
+          "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 claude_code_oauth_api_key?
+        api_key.to_s.start_with?("sk-ant-oat")
+      end
+
+      def claude_code_oauth_headers
+        {
+          "anthropic-version" => "2023-06-01",
+          "content-type" => "application/json",
+          "Authorization" => "Bearer #{api_key}",
+          "anthropic-dangerous-direct-browser-access" => "true",
+          "anthropic-beta" => "claude-code-20250219,oauth-2025-04-20",
+          "user-agent" => "claude-cli/#{CLAUDE_CODE_VERSION} (external, cli)",
+          "x-app" => "cli"
+        }
+      end
+
+      def prepend_claude_code_identity(system)
+        identity = {
+          type: "text",
+          text: "You are Claude Code, Anthropic's official CLI for Claude."
+        }
+
+        if system.nil? || system.empty?
+          [ identity ]
+        else
+          [ identity ] + system
+        end
+      end
+
+      def handle_client_specific_errors(response, error)
+        if Errors.context_overflow_message?(error["message"])
+          raise Errors::PromptTooLong.new(error["message"], error["type"])
+        end
+
+        raise Errors::APIStatusError.new(error["message"], error["type"])
+      end
+    end
+  end
+end

data/lib/llm_gateway/clients/claude_code/oauth_flow.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "securerandom"
+require "digest"
+require "base64"
+require "uri"
+require "time"
+
+module LlmGateway
+  module Clients
+    module ClaudeCode
+      class OAuthFlow
+        CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+        TOKEN_URL = "https://api.anthropic.com/v1/oauth/token"
+        AUTH_URL = "https://claude.ai/oauth/authorize"
+        REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback"
+        DEFAULT_SCOPES = "org:create_api_key user:profile user:inference"
+
+        attr_reader :client_id, :redirect_uri, :scopes
+
+        def initialize(
+          client_id: CLIENT_ID,
+          redirect_uri: REDIRECT_URI,
+          scopes: DEFAULT_SCOPES
+        )
+          @client_id = client_id
+          @redirect_uri = redirect_uri
+          @scopes = scopes
+        end
+
+        # Step 1: Generate the authorization URL for the user to visit.
+        # Returns a hash with everything needed to complete the flow later.
+        def start(state: SecureRandom.hex(16))
+          code_verifier, code_challenge = generate_pkce
+
+          auth_url = build_authorization_url(code_challenge, state)
+
+          {
+            authorization_url: auth_url,
+            code_verifier: code_verifier,
+            state: state
+          }
+        end
+
+        # Step 2: Exchange the authorization code for tokens.
+        # Accepts one of:
+        # - "code#state" (legacy format)
+        # - a raw authorization code, with state passed separately
+        # - a full callback URL containing ?code=...&state=...
+        # Returns { access_token:, refresh_token:, expires_at: }
+        def exchange_code(auth_code_or_callback, code_verifier, state: nil)
+          code, resolved_state = extract_code_and_state(auth_code_or_callback, state)
+
+          uri = URI(TOKEN_URL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.read_timeout = 30
+          http.open_timeout = 10
+
+          request = Net::HTTP::Post.new(uri)
+          request["Content-Type"] = "application/json"
+
+          request.body = {
+            grant_type: "authorization_code",
+            client_id: @client_id,
+            code: code,
+            state: resolved_state || "",
+            redirect_uri: @redirect_uri,
+            code_verifier: code_verifier
+          }.to_json
+
+          response = http.request(request)
+
+          if response.code.to_i == 200
+            data = JSON.parse(response.body)
+
+            expires_at = if data["expires_in"]
+                           Time.now + data["expires_in"].to_i
+            elsif data["expires_at"]
+                           Time.parse(data["expires_at"])
+            end
+
+            {
+              access_token: data["access_token"],
+              refresh_token: data["refresh_token"],
+              expires_at: expires_at
+            }
+          else
+            error_body = begin
+              JSON.parse(response.body)
+            rescue StandardError
+              {}
+            end
+            raise Errors::AuthenticationError.new(
+              "OAuth token exchange failed: #{error_body["error_description"] || error_body["error"] || response.body}",
+              error_body["error"]
+            )
+          end
+        end
+
+        def parse_callback(callback_url)
+          uri = URI(callback_url)
+          code = uri.query && URI.decode_www_form(uri.query).to_h["code"]
+          state = uri.query && URI.decode_www_form(uri.query).to_h["state"]
+
+          raise ArgumentError, "Callback URL is missing code parameter" if code.nil? || code.empty?
+
+          { code: code, state: state }
+        rescue URI::InvalidURIError => e
+          raise ArgumentError, "Invalid callback URL: #{e.message}"
+        end
+
+        private
+
+        def extract_code_and_state(auth_code_or_callback, state)
+          value = auth_code_or_callback.to_s.strip
+          raise ArgumentError, "Authorization code is required" if value.empty?
+
+          if looks_like_url?(value)
+            callback = parse_callback(value)
+            [ callback[:code], callback[:state] || state ]
+          elsif value.include?("#")
+            code, parsed_state = value.split("#", 2)
+            [ code, parsed_state || state ]
+          else
+            [ value, state ]
+          end
+        end
+
+        def looks_like_url?(value)
+          value.start_with?("http://", "https://")
+        end
+
+        def generate_pkce
+          code_verifier = [ SecureRandom.random_bytes(32) ].pack("m0").tr("+/", "-_").tr("=", "")
+
+          digest = Digest::SHA256.digest(code_verifier)
+          code_challenge = [ digest ].pack("m0").tr("+/", "-_").tr("=", "")
+
+          [ code_verifier, code_challenge ]
+        end
+
+        def build_authorization_url(code_challenge, state)
+          params = {
+            code: "true",
+            client_id: @client_id,
+            response_type: "code",
+            redirect_uri: @redirect_uri,
+            scope: @scopes,
+            code_challenge: code_challenge,
+            code_challenge_method: "S256",
+            state: state
+          }
+
+          "#{AUTH_URL}?#{URI.encode_www_form(params)}"
+        end
+      end
+    end
+  end
+end

data/lib/llm_gateway/clients/claude_code/token_manager.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "time"
+
+module LlmGateway
+  module Clients
+    module ClaudeCode
+      class TokenManager
+        TOKEN_URL = "https://api.anthropic.com/v1/oauth/token"
+        CLIENT_ID = OAuthFlow::CLIENT_ID
+
+        attr_reader :refresh_token, :expires_at, :client_id, :client_secret, :access_token
+        attr_accessor :on_token_refresh
+
+        def initialize(
+          access_token: nil,
+          refresh_token:,
+          expires_at: nil,
+          client_id: CLIENT_ID,
+          client_secret: nil
+        )
+          @access_token = access_token
+          @refresh_token = refresh_token
+          @expires_at = parse_expires_at(expires_at)
+          @client_id = client_id
+          @client_secret = client_secret
+          @on_token_refresh = nil
+        end
+
+        def token_expired?
+          return true if @expires_at.nil?
+          Time.now >= @expires_at
+        end
+
+        def ensure_valid_token
+          refresh_access_token if token_expired?
+        end
+
+        def refresh_access_token
+          raise ArgumentError, "Cannot refresh token: refresh_token not provided" unless @refresh_token
+          raise ArgumentError, "Cannot refresh token: client_id not provided" unless @client_id
+
+          uri = URI(TOKEN_URL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.read_timeout = 30
+          http.open_timeout = 10
+
+          request = Net::HTTP::Post.new(uri)
+          request["Content-Type"] = "application/json"
+
+          request_body = {
+            grant_type: "refresh_token",
+            client_id: @client_id,
+            refresh_token: @refresh_token
+          }
+          request_body[:client_secret] = @client_secret if @client_secret
+
+          request.body = request_body.to_json
+
+          response = http.request(request)
+
+          if response.code.to_i == 200
+            data = JSON.parse(response.body)
+            @access_token = data["access_token"]
+
+            if data["refresh_token"]
+              @refresh_token = data["refresh_token"]
+            end
+
+            if data["expires_in"]
+              @expires_at = Time.now + data["expires_in"].to_i
+            elsif data["expires_at"]
+              @expires_at = Time.parse(data["expires_at"])
+            end
+
+            @on_token_refresh&.call(@access_token, @refresh_token, @expires_at)
+
+            @access_token
+          else
+            error_body = begin
+              JSON.parse(response.body)
+            rescue StandardError
+              {}
+            end
+            raise Errors::AuthenticationError.new(
+              "Failed to refresh token: #{error_body['error'] || response.body}",
+              error_body["error_code"]
+            )
+          end
+        end
+
+        private
+
+        def parse_expires_at(expires)
+          case expires
+          when Time
+            expires
+          when String
+            Time.parse(expires)
+          when Integer
+            Time.at(expires)
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end