llm_gateway 0.3.0 → 0.5.0

data/lib/llm_gateway/adapters/openai_codex/responses_adapter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../adapter"
+require_relative "../openai/acts_like_responses"
+require_relative "option_mapper"
+require_relative "../openai/responses/stream_mapper"
+require_relative "../openai/file_output_mapper"
+require_relative "input_mapper"
+require_relative "../input_message_sanitizer"
+
+module LlmGateway
+  module Adapters
+    module OpenAICodex
+      class ResponsesAdapter < Adapter
+        include ActsLikeOpenAIResponses
+
+        private
+
+        def input_mapper
+          OpenAICodex::InputMapper
+        end
+
+        def option_mapper
+          OptionMapper
+        end
+
+        def perform_stream(messages, tools:, system:, **options, &block)
+          client.stream_codex(messages, tools: tools, system: system, **options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/option_mapper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module OptionMapper
+      module_function
+
+      def map(options)
+        options
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/stream_mapper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "normalized_stream_accumulator"
+
+module LlmGateway
+  module Adapters
+    class StreamMapper
+      def result
+        accumulator.result
+      end
+
+      private
+
+      def accumulator
+        @accumulator ||= LlmGateway::Adapters::NormalizedStreamAccumulator.new
+      end
+
+      def push_patches(patches, &block)
+        patches.each do |patch|
+          accumulator.push(patch, &block)
+        end
+
+        nil
+      end
+
+      def raise_stream_error!(data, overload_codes: [])
+        error = stream_error_payload(data)
+        message = error[:message] || error["message"] || "Stream error"
+        code = error[:code] || error["code"] || error[:type] || error["type"]
+
+        if LlmGateway::Errors.context_overflow_message?(message)
+          raise LlmGateway::Errors::PromptTooLong.new(message, code)
+        end
+
+        if Array(overload_codes).any? { |overload_code| overload_code.to_s == code.to_s }
+          raise LlmGateway::Errors::OverloadError.new(message, code)
+        end
+
+        raise LlmGateway::Errors::APIStatusError.new(message, code)
+      end
+
+      def stream_error_payload(data)
+        data ||= {}
+        error = data[:error] || data["error"]
+
+        error.is_a?(Hash) ? error : data
+      end
+    end
+  end
+end

data/lib/llm_gateway/adapters/structs.rb

@@ -0,0 +1,145 @@
+require "dry-struct"
+require "dry-types"
+
+module Types
+  include Dry.Types()
+end
+
+class BaseStruct < Dry::Struct
+  transform_keys(&:to_sym)
+end
+
+class AssistantStreamEvent < BaseStruct
+  EventType = Types::Coercible::Symbol.enum(:text_start, :text_delta, :text_end, :tool_start, :tool_delta, :tool_end, :reasoning_start, :reasoning_delta, :reasoning_end)
+
+  attribute :type, EventType
+  attribute :delta, Types::Coercible::String.default { "" }
+  attribute :content_index, Types::Integer
+end
+
+
+class AssistantToolStartEvent < AssistantStreamEvent
+  attribute :id, Types::String
+  attribute :name, Types::String
+  attribute :content_index, Types::Integer
+end
+
+
+class AssistantStreamReasoningEvent < AssistantStreamEvent
+  attribute :signature, Types::Coercible::String.default { "" }
+  attribute :content_index, Types::Integer
+end
+
+class AssistantStreamMessageEvent < BaseStruct
+  EventType = Types::Coercible::Symbol.enum(:message_start, :message_delta, :message_end)
+
+  attribute :type, EventType
+  attribute :delta, Types::Coercible::Hash.default { {} }
+  attribute :usage_increment, Types::Coercible::Hash.default { {} }
+end
+
+class TextContent < BaseStruct
+  attribute :type, Types::String.enum("text")
+  attribute :text, Types::String
+
+  def to_h
+    {
+      type: type,
+      text: text
+    }
+  end
+end
+
+class ReasoningContent < BaseStruct
+  attribute :type, Types::String.enum("reasoning")
+  attribute :reasoning, Types::String
+  attribute? :signature, Types::String.optional
+
+  def to_h
+    result = {
+      type: type,
+      reasoning: reasoning
+    }
+    result[:signature] = signature unless signature.nil?
+    result
+  end
+end
+
+class ToolCall < BaseStruct
+  attribute :id, Types::String
+  attribute :type, Types::String.enum("tool_use")
+  attribute :name, Types::String
+  attribute :input, Types::Hash
+
+  def to_h
+    {
+      id: id,
+      type: type,
+      name: name,
+      input: input
+    }
+  end
+end
+
+class ToolResult < BaseStruct
+  attribute :type, Types::String.enum("tool_result")
+  attribute :tool_use_id, Types::String
+  attribute :content, Types::String
+end
+
+class AssistantMessage < BaseStruct
+  ContentBlock =
+    Types.Instance(TextContent) |
+    Types.Instance(ReasoningContent) |
+    Types.Instance(ToolCall)
+
+  attribute :id, Types::String
+  attribute :model, Types::String
+  attribute :usage, Types::Hash
+  attribute :role, Types::String.enum("assistant")
+  attribute :stop_reason, Types::String.enum("stop", "length", "tool_use", "toolUse", "error", "aborted")
+  attribute :provider, Types::String
+  attribute :api, Types::String
+  attribute? :error_message, Types::String.optional
+  attribute :content, Types::Array.of(ContentBlock)
+
+  def self.new(attributes)
+    attrs = attributes.to_h.transform_keys(&:to_sym)
+    attrs[:content] = Array(attrs[:content]).map { |block| build_content_block(block) }
+    super(attrs)
+  end
+
+  def to_h
+    result = {
+      id: id,
+      model: model,
+      usage: usage,
+      role: role,
+      stop_reason: stop_reason,
+      provider: provider,
+      api: api,
+      content: content.map(&:to_h)
+    }
+    result[:error_message] = error_message unless error_message.nil?
+    result
+  end
+
+  def self.build_content_block(block)
+    return block if block.is_a?(TextContent) || block.is_a?(ReasoningContent) || block.is_a?(ToolCall)
+
+    case block[:type] || block["type"]
+    when "text"
+      TextContent.new(block)
+    when "reasoning"
+      ReasoningContent.new(block)
+    when "thinking"
+      ReasoningContent.new(type: "reasoning", reasoning: block[:thinking] || block["thinking"] || block[:reasoning] || block["reasoning"], signature: block[:signature] || block["signature"])
+    when "tool_use"
+      ToolCall.new(block)
+    else
+      raise ArgumentError, "Unsupported content block type: #{block[:type] || block['type']}"
+    end
+  end
+
+  private_class_method :build_content_block
+end

data/lib/llm_gateway/base_client.rb

@@ -60,8 +60,70 @@ module LlmGateway
       process_response(response)
     end
 
+    def post_stream(url_part, body = nil, extra_headers = {}, &block)
+      endpoint = "#{base_endpoint}/#{url_part.sub(%r{^/}, "")}"
+      uri = URI(endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.read_timeout = 480
+      http.open_timeout = 10
+      body.merge!(stream: true)
+      request = Net::HTTP::Post.new(uri)
+      headers = build_headers.merge(extra_headers)
+      headers.each { |key, value| request[key] = value }
+      request.body = body.to_json if body
+
+      http.request(request) do |response|
+        unless response.code.to_i == 200
+          # Collect full body for error handling
+          full_body = +""
+          response.read_body { |chunk| full_body << chunk }
+          # Create a response-like object with the body for handle_error
+          response.instance_variable_set(:@body, full_body)
+          response.instance_variable_set(:@read, true)
+          handle_error(response)
+        end
+
+        parse_sse_stream(response, &block)
+      end
+    end
+
     protected
 
+    def parse_sse_stream(response)
+      buffer = +""
+      response.read_body do |chunk|
+        buffer << chunk
+        while (idx = buffer.index("\n\n"))
+          raw_event = buffer.slice!(0, idx + 2)
+          event_type = nil
+          data_lines = []
+
+          raw_event.each_line do |line|
+            line = line.chomp
+            if line.start_with?("event:")
+              event_type = line.sub(/^event:\s*/, "")
+            elsif line.start_with?("data:")
+              data_lines << line.sub(/^data:\s*/, "")
+            end
+          end
+
+          next if data_lines.empty?
+
+          data_str = data_lines.join("\n")
+          next if data_str == "[DONE]"
+
+          data = begin
+            LlmGateway::Utils.deep_symbolize_keys(JSON.parse(data_str))
+          rescue JSON::ParserError
+            { raw: data_str }
+          end
+
+          yield({ event: event_type, data: data })
+        end
+      end
+    end
+
     def make_request(endpoint, method, params = nil, extra_headers = {})
       uri = URI(endpoint)
       http = Net::HTTP.new(uri.host, uri.port)
@@ -73,7 +135,6 @@ module LlmGateway
       headers = build_headers.merge(extra_headers)
       headers.each { |key, value| request[key] = value }
       request.body = params.to_json if params
-
       http.request(request)
     end
 

data/lib/llm_gateway/client.rb

@@ -1,175 +1,35 @@
 # frozen_string_literal: true
 
+
 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)
-    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)
-    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)
-    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)
-    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)
-    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.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
-      end
-    end
-
-    def self.get_provider_config_by_client(client)
-      provider_id = provider_id_from_client(client)
-      get_provider_config(provider_id)
-    end
-
-    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.normalize_messages(message)
-      if message.is_a?(String)
-        [ { 'role': "user", 'content': message } ]
-      else
-        message
-      end
+    def self.upload_file(provider, **kwargs)
+      api_key = kwargs.delete(:api_key)
+      adapter = LlmGateway.build_provider(
+        provider: provider,
+        api_key: api_key
+      )
+      adapter.upload_file(**kwargs)
     end
 
-    def self.normalize_response_format(response_format)
-      if response_format.is_a?(String)
-        { type: response_format }
-      else
-        response_format
-      end
+    def self.download_file(provider, **kwargs)
+      api_key = kwargs.delete(:api_key)
+      adapter = LlmGateway.build_provider(
+        provider: provider,
+        api_key: api_key
+      )
+      adapter.download_file(**kwargs)
     end
   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