last_llm 0.0.4

data/lib/last_llm/provider.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/typhoeus'
+require 'active_support/core_ext/hash/keys'
+
+module LastLLM
+  # Base class for all LLM providers
+  # Implements common functionality and defines the interface that all providers must implement
+  class Provider
+    attr_reader :name, :config
+
+    def initialize(name, config = {})
+      @name = name
+      @config = config
+
+      if instance_of?(Provider)
+        raise NotImplementedError, "#{self.class} is an abstract class and cannot be instantiated directly"
+      end
+
+      validate_config! unless config[:skip_validation]
+    end
+
+    # Generate text from a prompt
+    # @param prompt [String] The prompt to generate text from
+    # @param options [Hash] Generation options
+    # @option options [String] :model The model to use
+    # @option options [Float] :temperature (0.7) The temperature to use
+    # @option options [Integer] :max_tokens The maximum number of tokens to generate
+    # @return [String] The generated text
+    # @raise [NotImplementedError] If not implemented by subclass
+    def generate_text(prompt, options = {})
+      raise NotImplementedError, "#{self.class}##{__method__} must be implemented by subclass"
+    end
+
+    # Generate a structured object from a prompt
+    # @param prompt [String] The prompt to generate the object from
+    # @param schema [Dry::Schema::Params] The schema to validate against
+    # @param options [Hash] Generation options
+    # @option options [String] :model The model to use
+    # @option options [Float] :temperature (0.7) The temperature to use
+    # @return [Hash] The generated object
+    # @raise [NotImplementedError] If not implemented by subclass
+    def generate_object(prompt, schema, options = {})
+      raise NotImplementedError, "#{self.class}##{__method__} must be implemented by subclass"
+    end
+
+    # Handle request errors
+    # @param error [StandardError] The error to handle
+    # @raise [ApiError] A standardized API error
+    def handle_request_error(error)
+      status = nil
+      message = "API request failed: #{error.message}"
+
+      case error
+      when Faraday::ResourceNotFound
+        status = 404
+      when Faraday::ConnectionFailed
+        status = 503
+      when Faraday::TimeoutError
+        status = 504
+      when Faraday::Error
+        if error.respond_to?(:response) && error.response.is_a?(Hash)
+          status = error.response[:status]
+          body = error.response[:body]
+
+          # Try to extract a more helpful message from the response body
+          if body.is_a?(String) && !body.empty?
+            begin
+              parsed_body = JSON.parse(body)
+              message = "API error: #{parsed_body['error']['message'] || parsed_body['error']}" if parsed_body['error']
+            rescue JSON::ParserError
+              # Use default message if we can't parse the body
+            end
+          end
+        end
+      end
+
+      raise LastLLM::ApiError.new(message, status)
+    end
+
+    # Parse API response
+    # @param response [HTTParty::Response] The response to parse
+    # @return [Hash] The parsed response
+    # @raise [ApiError] If the response is invalid
+    def parse_response(response)
+      return {} if response.body.nil? || response.body.empty?
+
+      begin
+        response.body.deep_symbolize_keys
+      rescue JSON::ParserError
+        raise LastLLM::ApiError, "Invalid JSON response: #{response.body}"
+      end
+    end
+
+    private
+
+    # Validate provider configuration
+    # @raise [LastLLM::ConfigurationError] If the configuration is invalid
+    def validate_config!
+      raise LastLLM::ConfigurationError, 'API key is required' unless @config[:api_key]
+    end
+
+    def parse_error_body(body)
+      return {} if body.nil? || body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      { 'error' => body }
+    end
+
+    def deep_symbolize_keys(hash)
+      return hash unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = case value
+                             when Hash then deep_symbolize_keys(value)
+                             when Array then value.map { |item| deep_symbolize_keys(item) }
+                             else value
+                             end
+      end
+    end
+
+    protected
+
+    def connection(base_url)
+      Faraday.new(url: base_url) do |f|
+        f.request :json
+        f.response :json
+        f.response :raise_error
+
+        # Try to use Typhoeus if available, otherwise fall back to default adapter
+        adapter = begin
+          Faraday::Adapter::Typhoeus
+        rescue StandardError
+          Faraday.default_adapter
+        end
+        f.adapter adapter
+
+        f.options.timeout = @config[:request_timeout] || 30
+        f.options.open_timeout = 10
+        f.options.proxy = @config[:proxy] if @config[:proxy]
+
+        if respond_to?(:setup_authorization, true)
+          setup_authorization(f)
+        elsif @config[:api_key]
+          f.headers['Authorization'] = "Bearer #{@config[:api_key]}"
+        end
+      end
+    end
+  end
+end

data/lib/last_llm/providers/anthropic.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'last_llm/providers/constants'
+
+module LastLLM
+  module Providers
+    # Anthropic provider implementation
+    class Anthropic < LastLLM::Provider
+      BASE_ENDPOINT = 'https://api.anthropic.com'
+
+      def initialize(config)
+        super(:anthropic, config)
+        @conn = connection(config[:base_url] || BASE_ENDPOINT)
+      end
+
+      def generate_text(prompt, options = {})
+        options = options.dup
+        messages = format_messages(prompt, options)
+
+        body = {
+          model: options[:model] || @config[:model] || 'claude-3-5-haiku-latest',
+          messages: messages,
+          max_tokens: options[:max_tokens] || 8192,
+          temperature: options[:temperature] || 0.2,
+          top_p: options[:top_p] || 0.8,
+          stream: false
+        }
+
+        # Add system parameter if system prompt is provided
+        body[:system] = options[:system_prompt] if options[:system_prompt]
+
+        response = @conn.post('/v1/messages') do |req|
+          req.body = body.compact
+        end
+
+        result = parse_response(response)
+        content = result.dig(:content, 0, :text)
+
+        content.to_s
+      rescue Faraday::Error => e
+        handle_request_error(e)
+      end
+
+      def generate_object(prompt, schema, options = {})
+        options = options.dup
+        system_prompt = 'You are a helpful assistant that responds with valid JSON.'
+        formatted_prompt = LastLLM::StructuredOutput.format_prompt(prompt, schema)
+
+        options[:system_prompt] = system_prompt
+
+        body = {
+          model: options[:model] || @config[:model] || 'claude-3-5-haiku-latest',
+          messages: [{ role: 'user', content: formatted_prompt }],
+          max_tokens: options[:max_tokens] || 8192,
+          system: options[:system_prompt],
+          temperature: options[:temperature] || 0.2,
+          top_p: options[:top_p] || 0.8,
+          stream: false
+        }.compact
+
+        response = @conn.post('/v1/messages') do |req|
+          req.body = body
+        end
+
+        result = parse_response(response)
+        content = result.dig(:content, 0, :text)
+
+        begin
+          JSON.parse(content, symbolize_names: true)
+        rescue JSON::ParserError => e
+          raise ApiError, "Invalid JSON response: #{e.message}"
+        end
+      rescue Faraday::Error => e
+        handle_request_error(e)
+      end
+
+      # Format a tool for Anthropic tools format
+      # @param tool [LastLLM::Tool] The tool to format
+      # @return [Hash] The tool in Anthropic format
+      def self.format_tool(tool)
+        {
+          name: tool.name,
+          description: tool.description,
+          input_schema: tool.parameters
+        }
+      end
+
+      # Execute a tool from an Anthropic response
+      # @param tool [LastLLM::Tool] The tool to execute
+      # @param response [Hash] The Anthropic response containing tool use information
+      # @return [Hash, nil] The result of the function call or nil if the tool wasn't used
+      def self.execute_tool(tool, response)
+        tool_use = response[:tool_use]
+        return nil unless tool_use && tool_use[:name] == tool.name
+
+        tool.call(tool_use[:input])
+      end
+
+      private
+
+      def format_messages(prompt, options)
+        if prompt.is_a?(Array) && prompt.all? { |m| m.is_a?(Hash) && m[:role] && m[:content] }
+          # Extract system message if present
+          system_messages = prompt.select { |m| m[:role] == 'system' }
+
+          # Set system_prompt if a system message was found
+          if system_messages.any? && !options[:system_prompt]
+            options[:system_prompt] = system_messages.map { |m| m[:content] }.join("\n")
+          end
+
+          # Return only non-system messages
+          prompt.reject { |m| m[:role] == 'system' }
+        else
+          [{ role: 'user', content: prompt.to_s }]
+        end
+      end
+
+      def setup_authorization(conn)
+        conn.headers['x-api-key'] = @config[:api_key]
+        conn.headers['anthropic-version'] = '2023-06-01'
+      end
+    end
+  end
+end

data/lib/last_llm/providers/constants.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Constants for provider names
+# This module centralizes all provider name definitions to follow DRY principles
+module Constants
+  OPENAI = :openai
+  ANTHROPIC = :anthropic
+  GOOGLE_GEMINI = :google_gemini
+  DEEPSEEK = :deepseek
+  OLLAMA = :ollama
+  TEST = :test
+
+  # Returns all available provider names
+  # @return [Array<Symbol>] List of all provider names
+  def self.all
+    [OPENAI, ANTHROPIC, GOOGLE_GEMINI, DEEPSEEK, OLLAMA, TEST]
+  end
+
+  # Check if a provider name is valid
+  # @param provider_name [Symbol] The provider name to check
+  # @return [Boolean] Whether the provider name is valid
+  def self.valid?(provider_name)
+    all.include?(provider_name)
+  end
+end
+
+# Also define it in the LastLLM namespace for consistency
+module LastLLM
+  module Providers
+    # Reference to the Constants module defined above
+    Constants = ::Constants
+  end
+end

data/lib/last_llm/providers/deepseek.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'last_llm/providers/constants'
+
+# Deepseek provider implementation
+class Deepseek < LastLLM::Provider
+  BASE_ENDPOINT = 'https://api.deepseek.com'
+
+  def initialize(config)
+    super(Constants::DEEPSEEK, config)
+    @conn = connection(config[:base_url] || BASE_ENDPOINT)
+  end
+
+  def generate_text(prompt, options = {})
+    messages = format_messages(prompt, options)
+
+    response = @conn.post('/v1/chat/completions') do |req|
+      req.body = {
+        model: options[:model] || @config[:model] || 'deepseek-chat',
+        messages: messages,
+        temperature: options[:temperature] || 0.7,
+        top_p: options[:top_p] || 0.8,
+        max_tokens: options[:max_tokens],
+        stream: false
+      }.compact
+    end
+
+    result = parse_response(response)
+    content = result.dig(:choices, 0, :message, :content)
+
+    content.to_s
+  rescue Faraday::Error => e
+    handle_request_error(e)
+  end
+
+  def generate_object(prompt, schema, options = {})
+    system_prompt = 'You are a helpful assistant that responds with valid JSON.'
+    formatted_prompt = LastLLM::StructuredOutput.format_prompt(prompt, schema)
+
+    messages = [
+      { role: 'system', content: system_prompt },
+      { role: 'user', content: formatted_prompt }
+    ]
+
+    response = @conn.post('/v1/chat/completions') do |req|
+      req.body = {
+        model: options[:model] || @config[:model] || 'deepseek-chat',
+        messages: messages,
+        temperature: options[:temperature] || 0.2,
+        top_p: options[:top_p] || 0.8,
+        stream: false
+      }.compact
+    end
+
+    result = parse_response(response)
+    content = result.dig(:choices, 0, :message, :content)
+
+    begin
+      JSON.parse(content, symbolize_names: true)
+    rescue JSON::ParserError => e
+      # Try to clean markdown code blocks and parse again
+      content.gsub!("```json\n", '').gsub!("\n```", '')
+      begin
+        JSON.parse(content, symbolize_names: true)
+      rescue JSON::ParserError
+        raise LastLLM::ApiError, "Invalid JSON response: #{e.message}"
+      end
+    end
+  rescue Faraday::Error => e
+    handle_request_error(e)
+  end
+
+  private
+
+  def format_messages(prompt, options)
+    if prompt.is_a?(Array) && prompt.all? { |m| m.is_a?(Hash) && m[:role] && m[:content] }
+      prompt
+    elsif options[:system_prompt]
+      [
+        { role: 'system', content: options[:system_prompt] },
+        { role: 'user', content: prompt.to_s }
+      ]
+    else
+      [{ role: 'user', content: prompt.to_s }]
+    end
+  end
+
+  # Format a tool for Deepseek function calling
+  # @param tool [LastLLM::Tool] The tool to format
+  # @return [Hash] The tool in Deepseek format
+  def self.format_tool(tool)
+    {
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }
+  end
+
+  # Execute a tool from a Deepseek response
+  # @param tool [LastLLM::Tool] The tool to execute
+  # @param response [Hash] The Deepseek response containing tool call information
+  # @return [Hash, nil] The result of the function call or nil if the tool wasn't called
+  def self.execute_tool(tool, response)
+    tool_call = response.dig(:choices, 0, :message, :tool_calls)&.first
+    return nil unless tool_call && tool_call[:function][:name] == tool.name
+
+    arguments = JSON.parse(tool_call[:function][:arguments], symbolize_names: true)
+    tool.call(arguments)
+  end
+end
+
+# Also define it in the LastLLM::Providers namespace for consistency
+module LastLLM
+  module Providers
+    # Reference to the Deepseek class defined above
+    Deepseek = ::Deepseek
+  end
+end

data/lib/last_llm/providers/google_gemini.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'last_llm/providers/constants'
+
+# Google Gemini provider implementation
+class GoogleGemini < LastLLM::Provider
+  BASE_ENDPOINT = 'https://generativelanguage.googleapis.com'
+
+  def initialize(config)
+    super(Constants::GOOGLE_GEMINI, config)
+    @api_key = config[:api_key]
+    @conn = connection(config[:base_url] || BASE_ENDPOINT)
+  end
+
+  def generate_text(prompt, options = {})
+    model = options[:model] || @config[:model] || 'gemini-1.5-flash'
+    contents = format_contents(prompt, options)
+
+    response = @conn.post("/v1beta/models/#{model}:generateContent?key=#{@api_key}") do |req|
+      req.body = {
+        contents: contents,
+        generationConfig: {
+          maxOutputTokens: options[:max_tokens],
+          temperature: options[:temperature] || 0.3,
+          topP: options[:top_p] || 0.95,
+          topK: options[:top_k] || 40
+        }.compact
+      }.compact
+    end
+
+    # Check for error responses even when they don't raise exceptions
+    if response.status != 200
+      error = Faraday::Error.new("HTTP #{response.status}")
+      error.instance_variable_set(:@response, { status: response.status, body: response.body.to_json })
+      return handle_gemini_error(error)
+    end
+
+    result = parse_response(response)
+    content = result.dig(:candidates, 0, :content, :parts, 0, :text)
+
+    content.to_s
+  rescue Faraday::Error => e
+    handle_gemini_error(e)
+  end
+
+  def generate_object(prompt, schema, options = {})
+    model = options[:model] || @config[:model] || 'gemini-1.5-flash'
+    contents = format_contents(prompt, options)
+
+    response = @conn.post("/v1beta/models/#{model}:generateContent?key=#{@api_key}") do |req|
+      req.body = {
+        contents: contents,
+        generationConfig: {
+          temperature: options[:temperature] || 0.7,
+          maxOutputTokens: options[:max_tokens],
+          topP: options[:top_p] || 0.95,
+          topK: options[:top_k] || 40,
+          responseMimeType: 'application/json',
+          responseSchema: schema
+        }.compact
+      }.compact
+    end
+
+    # Check for error responses even when they don't raise exceptions
+    if response.status != 200
+      error = Faraday::Error.new("HTTP #{response.status}")
+      error.instance_variable_set(:@response, { status: response.status, body: response.body.to_json })
+      return handle_gemini_error(error)
+    end
+
+    result = parse_response(response)
+    content = result.dig(:candidates, 0, :content, :parts, 0, :text)
+
+    begin
+      JSON.parse(content, symbolize_names: true)
+    rescue JSON::ParserError => e
+      raise LastLLM::ApiError, "Invalid JSON response: #{e.message}"
+    end
+  rescue Faraday::Error => e
+    handle_gemini_error(e)
+  end
+
+  private
+
+  def connection(endpoint)
+    Faraday.new(url: endpoint) do |faraday|
+      faraday.request :json
+      faraday.response :json, content_type: /\bjson$/
+      faraday.adapter Faraday.default_adapter
+    end
+  end
+
+  def format_contents(prompt, options)
+    if prompt.is_a?(Array)
+      prompt.map { |m| { role: m[:role], parts: [{ text: m[:content] }] } }
+    elsif options[:system_prompt]
+      [
+        { role: 'user', parts: [{ text: options[:system_prompt] }] },
+        { role: 'user', parts: [{ text: prompt.to_s }] }
+      ]
+    else
+      [{ role: 'user', parts: [{ text: prompt.to_s }] }]
+    end
+  end
+
+  # Format a tool for Google Gemini function calling
+  # @param tool [LastLLM::Tool] The tool to format
+  # @return [Hash] The tool in Google Gemini format
+  def self.format_tool(tool)
+    {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  end
+
+  # Execute a tool from a Google Gemini response
+  # @param tool [LastLLM::Tool] The tool to execute
+  # @param response [Hash] The Google Gemini response containing function call information
+  # @return [Hash, nil] The result of the function call or nil if the tool wasn't called
+  def self.execute_tool(tool, response)
+    function_call = response.dig(:candidates, 0, :content, :parts, 0, :functionCall)
+    return nil unless function_call && function_call[:name] == tool.name
+
+    arguments = function_call[:args]
+    tool.call(arguments)
+  end
+
+  # Custom error handler for Gemini API responses
+  def handle_gemini_error(error)
+    status = nil
+    message = "API request failed: #{error.message}"
+
+    if error.respond_to?(:response) && error.response.is_a?(Hash)
+      status = error.response[:status]
+      body = error.response[:body]
+
+      if body.is_a?(String) && !body.empty?
+        begin
+          parsed_body = JSON.parse(body)
+          # Handle array response format
+          if parsed_body.is_a?(Array) && parsed_body[0] && parsed_body[0]['error']
+            error_obj = parsed_body[0]['error']
+            message = "API error: #{error_obj['message'] || error_obj}"
+          # Handle object response format
+          elsif parsed_body['error']
+            error_message = parsed_body['error']['message'] || parsed_body['error']
+            error_code = parsed_body['error']['code']
+            error_status = parsed_body['error']['status']
+            message = "API error (#{error_code}): #{error_message}"
+            # Handle authentication errors
+            if error_code == 401 && error_status == 'UNAUTHENTICATED'
+              message = 'Authentication failed: Invalid API key or credentials. Please check your Google API key.'
+            elsif error_code == 400 && error_message.include?('API key not valid')
+              message = "Authentication failed: Invalid API key format or credentials. \
+              Please check your Google API key."
+            end
+          end
+        rescue JSON::ParserError
+          # Use default message if we can't parse the body
+        end
+      end
+    end
+
+    raise LastLLM::ApiError.new(message, status)
+  end
+end
+
+# Also define it in the LastLLM::Providers namespace for consistency
+module LastLLM
+  module Providers
+    # Reference to the GoogleGemini class defined above
+    GoogleGemini = ::GoogleGemini
+  end
+end