active_genie 0.0.24 → 0.0.25

data/lib/active_genie/clients/{base_client.rb → providers/base_client.rb}

@@ -1,15 +1,14 @@
+# frozen_string_literal: true
+
 module ActiveGenie
   module Clients
     class BaseClient
       class ClientError < StandardError; end
-      class RateLimitError < ClientError; end
-      class TimeoutError < ClientError; end
-      class NetworkError < ClientError; end
 
       DEFAULT_HEADERS = {
         'Content-Type': 'application/json',
         'Accept': 'application/json',
-        'User-Agent': 'ActiveGenie/1.0',
+        'User-Agent': "ActiveGenie/#{ActiveGenie::VERSION}"
       }.freeze
 
       DEFAULT_TIMEOUT = 60 # seconds
@@ -17,10 +16,8 @@ module ActiveGenie
       DEFAULT_MAX_RETRIES = 3
       DEFAULT_RETRY_DELAY = 1 # seconds
 
-      attr_reader :app_config
-
       def initialize(config)
-        @app_config = config
+        @config = config
       end
 
       # Make a GET request to the specified endpoint
@@ -28,12 +25,11 @@ module ActiveGenie
       # @param endpoint [String] The API endpoint to call
       # @param headers [Hash] Additional headers to include in the request
       # @param params [Hash] Query parameters for the request
-      # @param config [Hash] Configuration options including timeout, retries, etc.
       # @return [Hash, nil] The parsed JSON response or nil if empty
-      def get(endpoint, params: {}, headers: {}, config: {})
+      def get(endpoint, params: {}, headers: {})
         uri = build_uri(endpoint, params)
         request = Net::HTTP::Get.new(uri)
-        execute_request(uri, request, headers, config)
+        execute_request(uri, request, headers)
       end
 
       # Make a POST request to the specified endpoint
@@ -41,13 +37,12 @@ module ActiveGenie
       # @param endpoint [String] The API endpoint to call
       # @param payload [Hash] The request body to send
       # @param headers [Hash] Additional headers to include in the request
-      # @param config [Hash] Configuration options including timeout, retries, etc.
       # @return [Hash, nil] The parsed JSON response or nil if empty
-      def post(endpoint, payload, params: {}, headers: {}, config: {})
+      def post(endpoint, payload, params: {}, headers: {})
         uri = build_uri(endpoint, params)
         request = Net::HTTP::Post.new(uri)
         request.body = payload.to_json
-        execute_request(uri, request, headers, config)
+        execute_request(uri, request, headers)
       end
 
       # Make a PUT request to the specified endpoint
@@ -55,13 +50,12 @@ module ActiveGenie
       # @param endpoint [String] The API endpoint to call
       # @param payload [Hash] The request body to send
       # @param headers [Hash] Additional headers to include in the request
-      # @param config [Hash] Configuration options including timeout, retries, etc.
       # @return [Hash, nil] The parsed JSON response or nil if empty
-      def put(endpoint, payload, headers: {}, config: {})
+      def put(endpoint, payload, headers: {})
         uri = build_uri(endpoint)
         request = Net::HTTP::Put.new(uri)
         request.body = payload.to_json
-        execute_request(uri, request, headers, config)
+        execute_request(uri, request, headers)
       end
 
       # Make a DELETE request to the specified endpoint
@@ -69,12 +63,11 @@ module ActiveGenie
       # @param endpoint [String] The API endpoint to call
       # @param headers [Hash] Additional headers to include in the request
       # @param params [Hash] Query parameters for the request
-      # @param config [Hash] Configuration options including timeout, retries, etc.
       # @return [Hash, nil] The parsed JSON response or nil if empty
-      def delete(endpoint, headers: {}, params: {}, config: {})
+      def delete(endpoint, headers: {}, params: {})
         uri = build_uri(endpoint, params)
         request = Net::HTTP::Delete.new(uri)
-        execute_request(uri, request, headers, config)
+        execute_request(uri, request, headers)
       end
 
       protected
@@ -84,62 +77,47 @@ module ActiveGenie
       # @param uri [URI] The URI for the request
       # @param request [Net::HTTP::Request] The request object
       # @param headers [Hash] Additional headers to include
-      # @param config [Hash] Configuration options
       # @return [Hash, nil] The parsed JSON response or nil if empty
-      def execute_request(uri, request, headers, config)
+      def execute_request(uri, request, headers)
         start_time = Time.now
-        
+
         # Apply headers
         apply_headers(request, headers)
-        
-        # Apply retry logic
-        retry_with_backoff(config) do
-          http = create_http_client(uri, config)
-          
-          begin
-            response = http.request(request)
-            
-            # Handle common HTTP errors
-            case response
-            when Net::HTTPSuccess
-              parsed_response = parse_response(response)
-              
-              # Log request details if logging is enabled
-              log_request_details(
-                uri: uri, 
-                method: request.method,
-                status: response.code,
-                duration: Time.now - start_time,
-                response: parsed_response
-              )
-              
-              parsed_response
-            when Net::HTTPTooManyRequests
-              raise RateLimitError, "Rate limit exceeded: #{response.body}"
-            when Net::HTTPClientError, Net::HTTPServerError
-              raise ClientError, "HTTP Error #{response.code}: #{response.body}"
-            else
-              raise ClientError, "Unexpected response: #{response.code} - #{response.body}"
-            end
-          rescue Timeout::Error, Errno::ETIMEDOUT
-            raise TimeoutError, "Request to #{uri} timed out"
-          rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH, SocketError => e
-            raise NetworkError, "Network error: #{e.message}"
-          end
+
+        http = create_http_client(uri)
+
+        response = http.request(request)
+
+        case response
+        when Net::HTTPSuccess
+          parsed_response = parse_response(response)
+
+          log_request_details(
+            uri: uri,
+            method: request.method,
+            status: response.code,
+            duration: Time.now - start_time,
+            response: parsed_response
+          )
+
+          parsed_response
+        when Net::HTTPTooManyRequests, Net::HTTPClientError, Net::HTTPServerError
+          raise ClientError, "HTTP Error: #{response.code} - #{response.body}"
+        else
+          raise ClientError, "Unexpected response: #{response.code} - #{response.body}"
         end
       end
 
       # Create and configure an HTTP client
       #
       # @param uri [URI] The URI for the request
-      # @param config [Hash] Configuration options
       # @return [Net::HTTP] Configured HTTP client
-      def create_http_client(uri, config)
+      def create_http_client(uri)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = (uri.scheme == 'https')
         http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        http.read_timeout = config.dig(:runtime, :timeout) || DEFAULT_TIMEOUT
-        http.open_timeout = config.dig(:runtime, :open_timeout) || DEFAULT_OPEN_TIMEOUT
+        http.read_timeout = @config.llm.read_timeout || DEFAULT_TIMEOUT
+        http.open_timeout = @config.llm.open_timeout || DEFAULT_OPEN_TIMEOUT
         http
       end
 
@@ -151,7 +129,7 @@ module ActiveGenie
         DEFAULT_HEADERS.each do |key, value|
           request[key] = value
         end
-        
+
         headers.each do |key, value|
           request[key.to_s] = value
         end
@@ -163,13 +141,10 @@ module ActiveGenie
       # @param params [Hash] Query parameters
       # @return [URI] The constructed URI
       def build_uri(endpoint, params = {})
-        base_url = @app_config.api_url
-        uri = URI("#{base_url}#{endpoint}")
-        
-        unless params.empty?
-          uri.query = URI.encode_www_form(params)
-        end
-        
+        uri = endpoint.is_a?(URI) ? endpoint : URI(endpoint)
+
+        uri.query = URI.encode_www_form(params) unless params.empty?
+
         uri
       end
 
@@ -179,7 +154,7 @@ module ActiveGenie
       # @return [Hash, nil] Parsed JSON or nil if empty
       def parse_response(response)
         return nil if response.body.nil? || response.body.empty?
-        
+
         begin
           JSON.parse(response.body)
         rescue JSON::ParserError => e
@@ -191,51 +166,50 @@ module ActiveGenie
       #
       # @param details [Hash] Request and response details
       def log_request_details(details)
-        return unless defined?(ActiveGenie::Logger)
-        
-        ActiveGenie::Logger.trace({
-          code: :http_request,
-          uri: details[:uri].to_s,
-          method: details[:method],
-          status: details[:status],
-          duration: details[:duration],
-          response_size: details[:response].to_s.bytesize
-        })
+        ActiveGenie::Logger.call(
+          {
+            code: :http_request,
+            uri: details[:uri].to_s,
+            method: details[:method],
+            status: details[:status],
+            duration: details[:duration],
+            response_size: details[:response].to_s.bytesize
+          }
+        )
       end
 
       # Retry a block with exponential backoff
       #
-      # @param config [Hash] Configuration options
       # @yield The block to retry
       # @return [Object] The result of the block
-      def retry_with_backoff(config = {})
-        max_retries = config.dig(:runtime, :max_retries) || DEFAULT_MAX_RETRIES
-        retry_delay = config.dig(:runtime, :retry_delay) || DEFAULT_RETRY_DELAY
-        
+      def retry_with_backoff
+        max_retries = @config.llm.max_retries || DEFAULT_MAX_RETRIES
+        retry_delay = @config.llm.retry_delay || DEFAULT_RETRY_DELAY
+
         retries = 0
-        
+
         begin
           yield
-        rescue RateLimitError, NetworkError => e
-          if retries < max_retries
-            sleep_time = retry_delay * (2 ** retries)
-            retries += 1
-            
-            ActiveGenie::Logger.trace({
+        rescue Net::HTTPError => e
+          raise unless retries < max_retries
+
+          sleep_time = retry_delay * (2**retries)
+          retries += 1
+
+          ActiveGenie::Logger.call(
+            {
               code: :retry_attempt,
               attempt: retries,
               max_retries: max_retries,
               delay: sleep_time,
               error: e.message
-            }) if defined?(ActiveGenie::Logger)
-            
-            sleep(sleep_time)
-            retry
-          else
-            raise
-          end
+            }
+          )
+
+          sleep(sleep_time)
+          retry
         end
       end
     end
   end
-end
+end

data/lib/active_genie/clients/providers/deepseek_client.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+
+require_relative './base_client'
+
+module ActiveGenie
+  module Clients
+    class DeepseekClient < BaseClient
+      class DeepseekError < ClientError; end
+      class RateLimitError < DeepseekError; end
+      class InvalidResponseError < StandardError; end
+
+      # Requests structured JSON output from the DeepSeek model based on a schema.
+      #
+      # @param messages [Array<Hash>] A list of messages representing the conversation history.
+      #   Each hash should have :role ('user', 'assistant', or 'system') and :content (String).
+      # @param function [Hash] A JSON schema definition describing the desired output format.
+      # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
+      def function_calling(messages, function)
+        model = @config.llm.model || @config.providers.deepseek.tier_to_model(@config.llm.model_tier)
+
+        payload = {
+          messages:,
+          tools: [{
+            type: 'function',
+            function: {
+              **function,
+              parameters: {
+                **function[:parameters],
+                additionalProperties: false
+              },
+              strict: true
+            }.compact
+          }],
+          tool_choice: { type: 'function', function: { name: function[:name] } },
+          stream: false,
+          model:
+        }
+
+        headers = {
+          'Authorization': "Bearer #{@config.providers.deepseek.api_key}"
+        }.compact
+
+        retry_with_backoff do
+          response = request_deepseek(payload, headers)
+
+          parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
+          parsed_response = parsed_response['message'] || parsed_response
+
+          if parsed_response.nil? || parsed_response.keys.empty?
+            raise InvalidResponseError,
+                  "Invalid response: #{parsed_response}"
+          end
+
+          ActiveGenie::Logger.call({ code: :function_calling, payload:, parsed_response: })
+
+          parsed_response
+        end
+      end
+
+      private
+
+      # Make a request to the DeepSeek API
+      #
+      # @param payload [Hash] The request payload
+      # @param headers [Hash] Additional headers
+      # @return [Hash] The parsed response
+      def request_deepseek(payload, headers)
+        start_time = Time.now
+        url = "#{@config.providers.deepseek.api_url}/chat/completions"
+
+        response = post(url, payload, headers: headers)
+        return nil if response.nil?
+
+        ActiveGenie::Logger.call({
+                                   code: :llm_usage,
+                                   input_tokens: response.dig('usage', 'prompt_tokens'),
+                                   output_tokens: response.dig('usage', 'completion_tokens'),
+                                   total_tokens: response.dig('usage', 'total_tokens'),
+                                   model: payload[:model],
+                                   duration: Time.now - start_time,
+                                   usage: response['usage']
+                                 })
+
+        response
+      end
+    end
+  end
+end

data/lib/active_genie/clients/providers/google_client.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+require_relative './base_client'
+
+module ActiveGenie
+  module Clients
+    # Client for interacting with the Google Generative Language API.
+    class GoogleClient < BaseClient
+      class GoogleError < ClientError; end
+      class RateLimitError < GoogleError; end
+
+      API_VERSION_PATH = '/v1beta/models'
+
+      # Requests structured JSON output from the Google Generative Language model based on a schema.
+      #
+      # @param messages [Array<Hash>] A list of messages representing the conversation history.
+      #   Each hash should have :role ('user' or 'model') and :content (String).
+      #   Google Generative Language uses 'user' and 'model' roles.
+      # @param function [Hash] A JSON schema definition describing the desired output format.
+      # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
+      def function_calling(messages, function)
+        model = @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+
+        contents = convert_messages_to_contents(messages, function)
+        contents << output_as_json_schema(function)
+
+        payload = {
+          contents: contents,
+          generationConfig: {
+            response_mime_type: 'application/json',
+            temperature: 0.1
+          }
+        }
+
+        endpoint = "#{API_VERSION_PATH}/#{model}:generateContent"
+        params = { key: provider_config.api_key }
+        headers = DEFAULT_HEADERS
+
+        retry_with_backoff do
+          start_time = Time.now
+          url = "#{provider_config.api_url}#{endpoint}"
+
+          response = post(url, payload, headers:, params:)
+
+          json_string = response&.dig('candidates', 0, 'content', 'parts', 0, 'text')
+          return nil if json_string.nil? || json_string.empty?
+
+          begin
+            parsed_response = JSON.parse(json_string)
+
+            # Log usage metrics
+            usage_metadata = response['usageMetadata'] || {}
+            prompt_tokens = usage_metadata['promptTokenCount'] || 0
+            candidates_tokens = usage_metadata['candidatesTokenCount'] || 0
+            total_tokens = usage_metadata['totalTokenCount'] || (prompt_tokens + candidates_tokens)
+
+            ActiveGenie::Logger.call({
+                                       code: :llm_usage,
+                                       input_tokens: prompt_tokens,
+                                       output_tokens: candidates_tokens,
+                                       total_tokens: total_tokens,
+                                       model: model,
+                                       duration: Time.now - start_time,
+                                       usage: usage_metadata
+                                     })
+
+            ActiveGenie::Logger.call({ code: :function_calling, payload:, parsed_response: })
+
+            normalize_function_output(parsed_response)
+          rescue JSON::ParserError => e
+            raise GoogleError, "Failed to parse Google API response: #{e.message} - Content: #{json_string}"
+          end
+        end
+      end
+
+      def provider_config
+        @config.providers.google
+      end
+
+      private
+
+      def normalize_function_output(output)
+        output = if output.is_a?(Array)
+                   output.dig(0, 'properties') || output[0]
+                 else
+                   output
+                 end
+
+        output.dig('input_schema', 'properties') || output
+      end
+
+      ROLE_TO_GOOGLE_ROLE = {
+        user: 'user',
+        assistant: 'model'
+      }.freeze
+
+      # Converts standard message format to Google's 'contents' format
+      # and injects JSON schema instructions.
+      # @param messages [Array<Hash>] Array of { role: 'user'/'assistant'/'system', content: '...' }
+      # @param function_schema [Hash] The JSON schema for the desired output.
+      # @return [Array<Hash>] Array formatted for Google's 'contents' field.
+      def convert_messages_to_contents(messages, _function_schema)
+        messages.map do |message|
+          {
+            role: ROLE_TO_GOOGLE_ROLE[message[:role].to_sym] || 'user',
+            parts: [{ text: message[:content] }]
+          }
+        end
+      end
+
+      def output_as_json_schema(function_schema)
+        json_instruction = <<~PROMPT
+          Generate a JSON object that strictly adheres to the following JSON schema:
+
+          ```json
+          #{JSON.pretty_generate(function_schema[:parameters])}
+          ```
+
+          IMPORTANT: Only output the raw JSON object. Do not include any other text, explanations, or markdown formatting like ```json ... ``` wrappers around the final output.
+        PROMPT
+
+        {
+          role: 'user',
+          parts: [{ text: json_instruction }]
+        }
+      end
+    end
+  end
+end

data/lib/active_genie/clients/providers/openai_client.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+
+require_relative './base_client'
+
+module ActiveGenie
+  module Clients
+    class OpenaiClient < BaseClient
+      class OpenaiError < ClientError; end
+      class RateLimitError < OpenaiError; end
+      class InvalidResponseError < StandardError; end
+
+      # Requests structured JSON output from the OpenAI model based on a schema.
+      #
+      # @param messages [Array<Hash>] A list of messages representing the conversation history.
+      #   Each hash should have :role ('user', 'assistant', or 'system') and :content (String).
+      # @param function [Hash] A JSON schema definition describing the desired output format.
+      # @return [Hash, nil] The parsed JSON object matching the schema, or nil if parsing fails or content is empty.
+      def function_calling(messages, function)
+        model = @config.llm.model || provider_config.tier_to_model(@config.llm.model_tier)
+
+        payload = {
+          messages:,
+          tools: [{
+            type: 'function',
+            function: {
+              **function,
+              parameters: {
+                **function[:parameters],
+                additionalProperties: false
+              },
+              strict: true
+            }.compact
+          }],
+          tool_choice: { type: 'function', function: { name: function[:name] } },
+          stream: false,
+          model:
+        }
+
+        headers = {
+          'Authorization': "Bearer #{provider_config.api_key}"
+        }.compact
+
+        retry_with_backoff do
+          response = request_openai(payload, headers)
+
+          parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'tool_calls', 0, 'function', 'arguments'))
+          parsed_response = parsed_response['message'] || parsed_response
+
+          if parsed_response.nil? || parsed_response.keys.empty?
+            raise InvalidResponseError,
+                  "Invalid response: #{parsed_response}"
+          end
+
+          ActiveGenie::Logger.call({ code: :function_calling, payload:, parsed_response: })
+
+          parsed_response
+        end
+      end
+
+      def provider_config
+        @config.providers.openai
+      end
+
+      private
+
+      # Make a request to the OpenAI API
+      #
+      # @param payload [Hash] The request payload
+      # @param headers [Hash] Additional headers
+      # @return [Hash] The parsed response
+      def request_openai(payload, headers)
+        start_time = Time.now
+        url = "#{provider_config.api_url}/chat/completions"
+
+        response = post(url, payload, headers: headers)
+
+        return nil if response.nil?
+
+        ActiveGenie::Logger.call({
+                                   code: :llm_usage,
+                                   input_tokens: response.dig('usage', 'prompt_tokens'),
+                                   output_tokens: response.dig('usage', 'completion_tokens'),
+                                   total_tokens: response.dig('usage', 'total_tokens'),
+                                   model: payload[:model],
+                                   duration: Time.now - start_time,
+                                   usage: response['usage']
+                                 })
+
+        response
+      end
+    end
+  end
+end

data/lib/active_genie/clients/unified_client.rb

@@ -1,19 +1,49 @@
-module ActiveGenie::Clients
-  class UnifiedClient
-    class << self
-      def function_calling(messages, function, model_tier: nil, config: {})
-        provider_name = config[:runtime][:provider]&.to_s&.downcase&.strip&.to_sym || ActiveGenie.configuration.providers.default
-        provider_instance = ActiveGenie.configuration.providers.valid[provider_name]
+# frozen_string_literal: true
 
-        raise InvalidProviderError if provider_instance.nil? || provider_instance.client.nil?
+require_relative './providers/openai_client'
+require_relative './providers/anthropic_client'
+require_relative './providers/google_client'
+require_relative './providers/deepseek_client'
+require_relative '../errors/invalid_provider_error'
 
-        provider_instance.client.function_calling(messages, function, model_tier:, config:)
-      end
+module ActiveGenie
+  module Clients
+    class UnifiedClient
+      class InvalidProviderError < StandardError; end
 
-      private
+      class << self
+        PROVIDER_NAME_TO_CLIENT = {
+          openai: OpenaiClient,
+          anthropic: AnthropicClient,
+          google: GoogleClient,
+          deepseek: DeepseekClient
+        }.freeze
 
-      # TODO: improve error message
-      class InvalidProviderError < StandardError; end
+        def function_calling(messages, function, config: {})
+          client = config.llm.client
+
+          unless client
+            provider_name = config.llm.provider || config.providers.default
+            client = PROVIDER_NAME_TO_CLIENT[provider_name.to_sym]
+          end
+
+          raise ActiveGenie::InvalidProviderError, provider_name if client.nil?
+
+          response = client.new(config).function_calling(messages, function)
+
+          normalize_response(response)
+        end
+
+        private
+
+        def normalize_response(response)
+          response.each do |key, value|
+            response[key] = nil if ['null', 'none', 'undefined', '', 'unknown', '<unknown>'].include?(value.to_s.strip.downcase)
+          end
+
+          response
+        end
+      end
     end
   end
 end