llm_gateway 0.2.0 → 0.4.0

data/lib/llm_gateway/adapters/stream_accumulator.rb

@@ -0,0 +1,91 @@
+require "json"
+
+class StreamAccumulator
+  attr_accessor :blocks, :message_hash, :usage_hash
+
+  def initialize
+    @message_hash = {}
+    @usage_hash = {
+      input_tokens: 0,
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: 0,
+      output_tokens: 0,
+      reasoning_tokens: 0
+    }
+    @blocks = []
+  end
+
+  def result
+    message_hash.merge(
+      usage: usage_hash,
+      content: serialized_blocks
+    )
+  end
+
+  def push(event)
+    return unless event
+
+    case event.type
+    when :text_start
+      blocks[event.content_index] = {
+        type: "text",
+        text: ""
+      }
+      blocks[event.content_index][:text] += event.delta
+    when :text_delta, :text_end
+      blocks[event.content_index][:text] += event.delta
+    when :tool_start
+      blocks[event.content_index] = {
+        type: "tool_use",
+        id: event.id,
+        name: event.name,
+        input: ""
+      }
+    when :tool_delta, :tool_end
+      blocks[event.content_index][:input] += event.delta
+    when :message_start
+      message_hash.merge!(event.delta)
+      usage_hash.each_key do |key|
+        usage_hash[key] += event.usage_increment.fetch(key, 0)
+      end
+    when :reasoning_start
+      blocks[event.content_index] = {
+        type: "reasoning",
+        reasoning: "",
+        signature: ""
+      }
+      blocks[event.content_index][:reasoning] += event.delta
+      blocks[event.content_index][:signature] += event.respond_to?(:signature) ? event.signature : ""
+    when :reasoning_delta
+      blocks[event.content_index][:reasoning] += event.delta
+      blocks[event.content_index][:signature] += event.signature
+    when :reasoning_end
+      blocks[event.content_index][:reasoning] += event.delta
+      blocks[event.content_index][:signature] += event.respond_to?(:signature) ? event.signature : ""
+    when :message_delta
+      message_hash.merge!(event.delta)
+      usage_hash.each_key do |key|
+        usage_hash[key] += event.usage_increment.fetch(key, 0)
+      end
+    when :message_end
+    end
+  end
+
+  private
+
+  def serialized_blocks
+    blocks.map do |block|
+      next block unless block[:type] == "tool_use"
+
+      block.merge(input: LlmGateway::Utils.deep_symbolize_keys(parse_tool_input(block[:input])))
+    end
+  end
+
+  def parse_tool_input(input)
+    return {} if input.nil? || input.empty?
+
+    JSON.parse(input)
+  rescue JSON::ParserError
+    {}
+  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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "net/http"
+require "stringio"
 require "json"
 
 module LlmGateway
@@ -19,14 +20,110 @@ module LlmGateway
       process_response(response)
     end
 
+    def post_file(url_part, file_contents, filename, purpose: nil, mime_type: "application/octet-stream")
+      endpoint = "#{base_endpoint}/#{url_part.sub(%r{^/}, "")}"
+      uri = URI.parse(endpoint)
+
+      file_io = StringIO.new(file_contents)
+
+      # Create request with full URI (important!)
+      request = Net::HTTP::Post.new(uri)
+
+      form_data = [
+        [
+          "file",
+          file_io,
+          { filename: filename, "Content-Type" => mime_type }
+        ]
+      ]
+
+      # Add purpose parameter if provided
+      form_data << [ "purpose", purpose ] if purpose
+
+      request.set_form(form_data, "multipart/form-data")
+
+      # Headers (excluding Content-Type because set_form already sets it)
+      multipart_headers = build_headers.reject { |k, _| k.downcase == "content-type" }
+      multipart_headers.each { |key, value| request[key] = value }
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+
+
+      process_response(response)
+    end
+
     def post(url_part, body = nil, extra_headers = {})
       endpoint = "#{base_endpoint}/#{url_part.sub(%r{^/}, "")}"
       response = make_request(endpoint, Net::HTTP::Post, body, extra_headers)
       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)
@@ -38,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

@@ -2,78 +2,90 @@
 
 module LlmGateway
   class Client
-    def self.chat(model, message, response_format: "text", tools: nil, system: nil, api_key: nil)
-      client_klass = client_class(model)
-      client_options = { model_key: model }
-      client_options[:api_key] = api_key if api_key
-      client = client_klass.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.client_class(model)
-      return LlmGateway::Adapters::Claude::Client if model.start_with?("claude")
-      return LlmGateway::Adapters::Groq::Client if model.start_with?("llama")
-      return LlmGateway::Adapters::OpenAi::Client if model.start_with?("gpt") ||
-                                                     model.start_with?("o4-") ||
-                                                     model.start_with?("openai")
+    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
 
-      raise LlmGateway::Errors::UnsupportedModel, model
+    def self.build_client(provider, api_key:, model: "none")
+      adapter = LlmGateway.build_provider(
+        provider: provider,
+        api_key: api_key,
+        model_key: model
+      )
+      adapter.client
     end
 
-    def self.input_mapper_for_client(client)
-      return LlmGateway::Adapters::Claude::InputMapper if client.is_a?(LlmGateway::Adapters::Claude::Client)
-      return LlmGateway::Adapters::OpenAi::InputMapper if client.is_a?(LlmGateway::Adapters::OpenAi::Client)
+    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
 
-      LlmGateway::Adapters::Groq::InputMapper if client.is_a?(LlmGateway::Adapters::Groq::Client)
+    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
 
-    def self.result_mapper(client)
-      return LlmGateway::Adapters::Claude::OutputMapper if client.is_a?(LlmGateway::Adapters::Claude::Client)
-      return LlmGateway::Adapters::OpenAi::OutputMapper if client.is_a?(LlmGateway::Adapters::OpenAi::Client)
+    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")
 
-      LlmGateway::Adapters::Groq::OutputMapper if client.is_a?(LlmGateway::Adapters::Groq::Client)
+      raise LlmGateway::Errors::UnsupportedModel, model
     end
 
-    def self.normalize_system(system)
-      if system.nil?
-        []
-      elsif system.is_a?(String)
-        [ { role: "system", content: system } ]
-      elsif system.is_a?(Array)
-        system
+    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
-        raise ArgumentError, "System parameter must be a string or array, got #{system.class}"
+        client.class.name.downcase
       end
     end
 
-    def self.normalize_messages(message)
-      if message.is_a?(String)
-        [ { 'role': "user", 'content': message } ]
-      else
-        message
-      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)
 
-    def self.normalize_response_format(response_format)
-      if response_format.is_a?(String)
-        { type: response_format }
+      if api == "responses"
+        config = {
+          provider: "#{provider}_responses",
+          model_key: model
+        }
+        config[:api_key] = api_key if api_key
+        LlmGateway.build_provider(config)
       else
-        response_format
+        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/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