last_llm 0.0.4 → 0.0.6

data/lib/last_llm/providers/google_gemini.rb

@@ -2,174 +2,193 @@
 
 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
+module LastLLM
+  module Providers
+    # Google Gemini provider implementation
+    class GoogleGemini < LastLLM::Provider
+      # API Configuration
+      BASE_ENDPOINT = 'https://generativelanguage.googleapis.com'
+      DEFAULT_MODEL = 'gemini-1.5-flash'
+
+      # LLM Default Parameters
+      DEFAULT_TEMPERATURE = 0.3
+      DEFAULT_TOP_P = 0.95
+      DEFAULT_TOP_K = 40
+      DEFAULT_MAX_TOKENS = 1024
+
+      # Response Configuration
+      JSON_MIME_TYPE = 'application/json'
+      SUCCESS_STATUS = 200
+
+      # Error Status Codes
+      UNAUTHORIZED_STATUS = 401
+      BAD_REQUEST_STATUS = 400
+      UNAUTHENTICATED_STATUS = 'UNAUTHENTICATED'
+
+      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
+      def generate_text(prompt, options = {})
+        make_request(prompt, options) do |response|
+          extract_text_content(response)
+        end
+      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
+      def generate_object(prompt, schema, options = {})
+        options = options.merge(response_mime_type: JSON_MIME_TYPE, response_schema: schema)
+        make_request(prompt, options) do |response|
+          parse_json_response(extract_text_content(response))
+        end
+      end
 
-    result = parse_response(response)
-    content = result.dig(:candidates, 0, :content, :parts, 0, :text)
+      private
 
-    content.to_s
-  rescue Faraday::Error => e
-    handle_gemini_error(e)
-  end
+      def make_request(prompt, options = {})
+        model = options[:model] || @config[:model] || DEFAULT_MODEL
+        contents = format_contents(prompt, options)
+
+        response = @conn.post("/v1beta/models/#{model}:generateContent?key=#{@api_key}") do |req|
+          req.body = build_request_body(contents, options)
+        end
+
+        handle_response(response) { |result| yield(result) }
+      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
+      def build_request_body(contents, options)
+        {
+          contents: contents,
+          generationConfig: {
+            maxOutputTokens: options[:max_tokens] || DEFAULT_MAX_TOKENS,
+            temperature: options[:temperature] || DEFAULT_TEMPERATURE,
+            topP: options[:top_p] || DEFAULT_TOP_P,
+            topK: options[:top_k] || DEFAULT_TOP_K,
+            responseMimeType: options[:response_mime_type],
+            responseSchema: options[:response_schema]
+          }.compact
         }.compact
-      }.compact
-    end
+      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
+      def handle_response(response)
+        if response.status != SUCCESS_STATUS
+          error = build_error(response)
+          return handle_gemini_error(error)
+        end
 
-    result = parse_response(response)
-    content = result.dig(:candidates, 0, :content, :parts, 0, :text)
+        result = parse_response(response)
+        yield(result)
+      end
 
-    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
+      def build_error(response)
+        StandardError.new("HTTP #{response.status}").tap do |error|
+          error.define_singleton_method(:response) do
+            {
+              status: response.status,
+              body: response.body
+            }
+          end
+        end
+      end
 
-  private
+      def extract_text_content(response)
+        content = response.dig(:candidates, 0, :content, :parts, 0, :text)
+        content.to_s
+      end
 
-  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 parse_json_response(content)
+        JSON.parse(content, symbolize_names: true)
+      rescue JSON::ParserError => e
+        raise LastLLM::ApiError, "Invalid JSON response: #{e.message}"
+      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
+      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
 
-  # 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
+      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
 
-  # 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
+      def self.format_tool(tool)
+        {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        }
+      end
 
-    arguments = function_call[:args]
-    tool.call(arguments)
-  end
+      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
 
-  # 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
+        tool.call(function_call[:args])
       end
-    end
 
-    raise LastLLM::ApiError.new(message, status)
-  end
-end
+      def handle_gemini_error(error)
+        status = error.response&.dig(:status)
+        message = parse_error_message(error)
 
-# Also define it in the LastLLM::Providers namespace for consistency
-module LastLLM
-  module Providers
-    # Reference to the GoogleGemini class defined above
-    GoogleGemini = ::GoogleGemini
+        raise LastLLM::ApiError.new(message, status)
+      end
+
+      def parse_error_message(error)
+        return "API request failed: #{error.message}" unless error.response&.dig(:body)
+
+        body = parse_error_body(error.response[:body])
+        format_error_message(body)
+      rescue JSON::ParserError
+        "API request failed: #{error.message}"
+      end
+
+      def parse_error_body(body)
+        return {} unless body.is_a?(String) && !body.empty?
+        JSON.parse(body)
+      end
+
+      def format_error_message(body)
+        if body.is_a?(Array) && body[0]&.dig('error')
+          error_obj = body[0]['error']
+          "API error: #{error_obj['message'] || error_obj}"
+        elsif body['error']
+          format_detailed_error(body['error'])
+        else
+          'Unknown API error'
+        end
+      end
+
+      def format_detailed_error(error)
+        message = error['message']
+        code = error['code']
+        status = error['status']
+
+        case [code, status]
+        when [UNAUTHORIZED_STATUS, UNAUTHENTICATED_STATUS]
+          'Authentication failed: Invalid API key or credentials. Please check your Google API key.'
+        when [BAD_REQUEST_STATUS]
+          message.include?('API key not valid') ?
+            'Authentication failed: Invalid API key format or credentials. Please check your Google API key.' :
+            "API error (#{code}): #{message}"
+        else
+          "API error (#{code}): #{message}"
+        end
+      end
+    end
   end
 end

data/lib/last_llm/providers/ollama.rb

@@ -2,123 +2,136 @@
 
 require 'last_llm/providers/constants'
 
-# Ollama provider implementation
-class Ollama < LastLLM::Provider
-  BASE_ENDPOINT = 'http://172.17.0.1:11434'
+module LastLLM
+  module Providers
+    # Ollama provider implementation
+    class Ollama < LastLLM::Provider
+      # API Configuration
+      BASE_ENDPOINT = 'http://172.17.0.1:11434'
+      DEFAULT_MODEL = 'llama3.2:latest'
+
+      # LLM Default Parameters
+      DEFAULT_TEMPERATURE = 0.7
+      DEFAULT_TOP_P = 0.7
+      DEFAULT_MAX_TOKENS = 24_576
+      DEFAULT_TEMPERATURE_OBJECT = 0.2
+
+      # Response Configuration
+      SUCCESS_STATUS = 200
+
+      # Error Status Codes
+      SERVER_ERROR_STATUS = 500
+      BAD_REQUEST_STATUS = 400
+
+      def initialize(config)
+        super(Constants::OLLAMA, config)
+        @conn = connection(config[:base_url] || BASE_ENDPOINT)
+      end
 
-  def initialize(config)
-    super(Constants::OLLAMA, config)
-    @conn = connection(config[:base_url] || BASE_ENDPOINT)
-  end
+      def generate_text(prompt, options = {})
+        make_request(prompt, options) do |result|
+          result.dig(:choices, 0, :message, :content).to_s
+        end
+      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] || 'llama3.2:latest',
-        messages: messages,
-        temperature: options[:temperature] || 0.7,
-        top_p: options[:top_p] || 0.7,
-        max_tokens: options[:max_tokens] || 24_576,
-        stream: false
-      }.compact
-    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)
 
-    result = parse_response(response)
-    content = result.dig(:choices, 0, :message, :content)
+        options = options.dup
+        options[:system_prompt] = system_prompt
+        options[:temperature] ||= DEFAULT_TEMPERATURE_OBJECT
 
-    content.to_s
-  rescue Faraday::Error => e
-    handle_request_error(e)
-  end
+        make_request(formatted_prompt, options) do |result|
+          content = result.dig(:choices, 0, :message, :content)
+          parse_json_response(content)
+        end
+      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] || 'llama3.2:latest',
-        messages: messages,
-        temperature: options[:temperature] || 0.2,
-        stream: false
-      }.compact
-    end
+      # Format a tool for Ollama function calling
+      # @param tool [LastLLM::Tool] The tool to format
+      # @return [Hash] The tool in Ollama format
+      def self.format_tool(tool)
+        {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        }
+      end
 
-    result = parse_response(response)
-    content = result.dig(:choices, 0, :message, :content)
+      # Execute a tool from an Ollama response
+      # @param tool [LastLLM::Tool] The tool to execute
+      # @param response [Hash] The Ollama 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)
+        # Ollama doesn't have native function calling, so we need to parse from the content
+        # This is a simplified implementation that would need to be enhanced for production
+        content = response.dig(:message, :content)
+        return nil unless content&.include?(tool.name)
+
+        # Simple regex to extract JSON from the content
+        # This is a basic implementation and might need enhancement
+        if content =~ /#{tool.name}\s*\(([^)]+)\)/i
+          args_str = ::Regexp.last_match(1)
+          begin
+            args = JSON.parse("{#{args_str}}", symbolize_names: true)
+            return tool.call(args)
+          rescue JSON::ParserError
+            return nil
+          end
+        end
+
+        nil
+      end
 
-    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_request_error(e)
-  end
+      private
+
+      def make_request(prompt, options = {})
+        messages = format_messages(prompt, options)
+
+        response = @conn.post('/v1/chat/completions') do |req|
+          req.body = {
+            model: options[:model] || @config[:model] || DEFAULT_MODEL,
+            messages: messages,
+            temperature: options[:temperature] || DEFAULT_TEMPERATURE,
+            top_p: options[:top_p] || DEFAULT_TOP_P,
+            max_tokens: options[:max_tokens] || DEFAULT_MAX_TOKENS,
+            stream: false
+          }.compact
+        end
+
+        result = parse_response(response)
+        yield(result)
+      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
+      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 Ollama function calling
-  # @param tool [LastLLM::Tool] The tool to format
-  # @return [Hash] The tool in Ollama format
-  def self.format_tool(tool)
-    {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
-    }
-  end
+      def parse_json_response(content)
+        begin
+          JSON.parse(content, symbolize_names: true)
+        rescue JSON::ParserError => e
+          raise LastLLM::ApiError, "Invalid JSON response: #{e.message}"
+        end
+      end
 
-  # Execute a tool from an Ollama response
-  # @param tool [LastLLM::Tool] The tool to execute
-  # @param response [Hash] The Ollama 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)
-    # Ollama doesn't have native function calling, so we need to parse from the content
-    # This is a simplified implementation that would need to be enhanced for production
-    content = response.dig(:message, :content)
-    return nil unless content&.include?(tool.name)
-
-    # Simple regex to extract JSON from the content
-    # This is a basic implementation and might need enhancement
-    if content =~ /#{tool.name}\s*\(([^)]+)\)/i
-      args_str = ::Regexp.last_match(1)
-      begin
-        args = JSON.parse("{#{args_str}}", symbolize_names: true)
-        return tool.call(args)
-      rescue JSON::ParserError
-        return nil
+      def handle_request_error(error)
+        message = "Ollama API request failed: #{error.message}"
+        status = error.respond_to?(:response) && error.response.respond_to?(:status) ? error.response.status : nil
+        raise LastLLM::ApiError.new(message, status)
       end
     end
-
-    nil
-  end
-end
-
-# Also define it in the LastLLM::Providers namespace for consistency
-module LastLLM
-  module Providers
-    # Reference to the Ollama class defined above
-    Ollama = ::Ollama
   end
 end