desiru 0.1.0 → 0.1.1

data/lib/desiru/jobs/webhook_notifier.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Desiru
+  module Jobs
+    # Handles webhook notifications for job events
+    class WebhookNotifier
+      attr_reader :config
+
+      def initialize(config = {})
+        @config = {
+          timeout: 30,
+          retry_count: 3,
+          retry_delay: 1,
+          headers: {
+            'Content-Type' => 'application/json',
+            'User-Agent' => "Desiru/#{Desiru::VERSION}"
+          }
+        }.merge(config)
+      end
+
+      # Send a webhook notification
+      # @param url [String] the webhook URL
+      # @param payload [Hash] the payload to send
+      # @param options [Hash] additional options
+      # @return [WebhookResult] the result of the webhook call
+      def notify(url, payload, options = {})
+        uri = URI.parse(url)
+        headers = config[:headers].merge(options[:headers] || {})
+
+        # Add signature if secret is provided
+        if options[:secret]
+          signature = generate_signature(payload, options[:secret])
+          headers['X-Desiru-Signature'] = signature
+        end
+
+        attempt = 0
+        last_error = nil
+
+        while attempt < config[:retry_count]
+          attempt += 1
+
+          begin
+            response = send_request(uri, payload, headers)
+
+            if response.code.to_i >= 200 && response.code.to_i < 300
+              return WebhookResult.new(
+                success: true,
+                status_code: response.code.to_i,
+                body: response.body,
+                headers: response.to_hash,
+                attempts: attempt
+              )
+            else
+              last_error = "HTTP #{response.code}: #{response.body}"
+              Desiru.logger.warn("Webhook failed (attempt #{attempt}/#{config[:retry_count]}): #{last_error}")
+            end
+          rescue StandardError => e
+            last_error = e.message
+            Desiru.logger.error("Webhook error (attempt #{attempt}/#{config[:retry_count]}): #{e.message}")
+          end
+
+          # Retry with delay if not the last attempt
+          if attempt < config[:retry_count]
+            sleep(config[:retry_delay] * attempt) # Exponential backoff
+          end
+        end
+
+        # All attempts failed
+        WebhookResult.new(
+          success: false,
+          error: last_error,
+          attempts: attempt
+        )
+      end
+
+      private
+
+      def send_request(uri, payload, headers)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = config[:timeout]
+        http.open_timeout = config[:timeout]
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        headers.each { |key, value| request[key] = value }
+        request.body = payload.to_json
+
+        http.request(request)
+      end
+
+      def generate_signature(payload, secret)
+        require 'openssl'
+        digest = OpenSSL::Digest.new('sha256')
+        OpenSSL::HMAC.hexdigest(digest, secret, payload.to_json)
+      end
+    end
+
+    # Result of a webhook notification
+    class WebhookResult
+      attr_reader :success, :status_code, :body, :headers, :error, :attempts
+
+      def initialize(success:, status_code: nil, body: nil, headers: nil, error: nil, attempts: 1)
+        @success = success
+        @status_code = status_code
+        @body = body
+        @headers = headers
+        @error = error
+        @attempts = attempts
+      end
+
+      def success?
+        @success
+      end
+
+      def failed?
+        !@success
+      end
+    end
+
+    # Configuration for webhook notifications
+    class WebhookConfig
+      attr_accessor :enabled, :url, :secret, :events, :include_payload, :custom_headers
+
+      def initialize
+        @enabled = false
+        @url = nil
+        @secret = nil
+        @events = %i[completed failed] # Which events to notify on
+        @include_payload = true # Include job result in webhook
+        @custom_headers = {}
+      end
+
+      def valid?
+        enabled && url && !url.empty?
+      end
+    end
+
+    # Mixin to add webhook support to jobs
+    module Webhookable
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.instance_variable_set(:@webhook_config, WebhookConfig.new)
+      end
+
+      def self.prepended(base)
+        base.extend(ClassMethods)
+        base.instance_variable_set(:@webhook_config, WebhookConfig.new)
+      end
+
+      def perform(*args)
+        job_id = args.first || "job-#{Time.now.to_i}"
+        result = nil
+        error = nil
+        status = :completed
+
+        begin
+          # Call the original perform method
+          result = super
+        rescue StandardError => e
+          error = e
+          status = :failed
+          raise # Re-raise to maintain normal error handling
+        ensure
+          # Send webhook notification if configured
+          send_webhook_notification(job_id, status, result, error) if should_notify_webhook?(status)
+        end
+
+        result
+      end
+
+      module ClassMethods
+        def webhook_config
+          @webhook_config ||= WebhookConfig.new
+        end
+
+        def configure_webhook
+          yield(webhook_config) if block_given?
+        end
+
+        def webhook_enabled?
+          webhook_config.valid?
+        end
+      end
+
+      private
+
+      def should_notify_webhook?(status)
+        self.class.webhook_enabled? &&
+          self.class.webhook_config.events.include?(status)
+      end
+
+      def send_webhook_notification(job_id, status, result, error)
+        payload = build_webhook_payload(job_id, status, result, error)
+
+        notifier = WebhookNotifier.new
+        webhook_result = notifier.notify(
+          self.class.webhook_config.url,
+          payload,
+          secret: self.class.webhook_config.secret,
+          headers: self.class.webhook_config.custom_headers
+        )
+
+        if webhook_result.failed?
+          Desiru.logger.error("Failed to send webhook for job #{job_id}: #{webhook_result.error}")
+        else
+          Desiru.logger.info("Webhook notification sent for job #{job_id}")
+        end
+      rescue StandardError => e
+        # Don't let webhook failures affect job execution
+        Desiru.logger.error("Webhook notification error: #{e.message}")
+      end
+
+      def build_webhook_payload(job_id, status, result, error)
+        payload = {
+          job_id: job_id,
+          job_class: self.class.name,
+          status: status.to_s,
+          timestamp: Time.now.iso8601,
+          environment: ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+        }
+
+        if self.class.webhook_config.include_payload
+          if status == :completed && result
+            payload[:result] = result
+          elsif status == :failed && error
+            payload[:error] = {
+              class: error.class.name,
+              message: error.message,
+              backtrace: error.backtrace&.first(5) # Limit backtrace size
+            }
+          end
+        end
+
+        payload
+      end
+    end
+  end
+end

data/lib/desiru/models/anthropic.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'anthropic'
+
+module Desiru
+  module Models
+    # Anthropic Claude model adapter
+    class Anthropic < Base
+      DEFAULT_MODEL = 'claude-3-haiku-20240307'
+
+      def initialize(config = {})
+        super
+        @api_key = config[:api_key] || ENV.fetch('ANTHROPIC_API_KEY', nil)
+        raise ArgumentError, 'Anthropic API key is required' unless @api_key
+
+        @client = ::Anthropic::Client.new(access_token: @api_key)
+      end
+
+      def models
+        # Anthropic doesn't provide a models endpoint, so we maintain a list
+        # This list should be updated periodically as new models are released
+        @models ||= {
+          'claude-3-haiku-20240307' => {
+            name: 'Claude 3 Haiku',
+            max_tokens: 200_000,
+            description: 'Fast and efficient for simple tasks'
+          },
+          'claude-3-sonnet-20240229' => {
+            name: 'Claude 3 Sonnet',
+            max_tokens: 200_000,
+            description: 'Balanced performance and capability'
+          },
+          'claude-3-opus-20240229' => {
+            name: 'Claude 3 Opus',
+            max_tokens: 200_000,
+            description: 'Most capable model for complex tasks'
+          },
+          'claude-3-5-sonnet-20241022' => {
+            name: 'Claude 3.5 Sonnet',
+            max_tokens: 200_000,
+            description: 'Latest Sonnet with improved capabilities'
+          },
+          'claude-3-5-haiku-20241022' => {
+            name: 'Claude 3.5 Haiku',
+            max_tokens: 200_000,
+            description: 'Latest Haiku with enhanced speed'
+          }
+        }
+      end
+
+      protected
+
+      def perform_completion(messages, options)
+        model = options[:model] || @config[:model] || DEFAULT_MODEL
+        temperature = options[:temperature] || @config[:temperature] || 0.7
+        max_tokens = options[:max_tokens] || @config[:max_tokens] || 4096
+
+        # Convert messages to Anthropic format
+        system_message, user_messages = format_messages(messages)
+
+        # Prepare request parameters
+        params = {
+          model: model,
+          messages: user_messages,
+          max_tokens: max_tokens,
+          temperature: temperature
+        }
+
+        # Add system message if present
+        params[:system] = system_message if system_message
+
+        # Add tools if provided
+        if options[:tools]
+          params[:tools] = format_tools(options[:tools])
+          params[:tool_choice] = options[:tool_choice] if options[:tool_choice]
+        end
+
+        # Make API call
+        response = @client.messages(parameters: params)
+
+        # Format response
+        format_response(response, model)
+      rescue ::Faraday::Error => e
+        handle_api_error(e)
+      end
+
+      private
+
+      def format_messages(messages)
+        system_message = nil
+        user_messages = []
+
+        messages.each do |msg|
+          case msg[:role]
+          when 'system'
+            system_message = msg[:content]
+          when 'user'
+            user_messages << { role: 'user', content: msg[:content] }
+          when 'assistant'
+            user_messages << { role: 'assistant', content: msg[:content] }
+          end
+        end
+
+        [system_message, user_messages]
+      end
+
+      def format_tools(tools)
+        tools.map do |tool|
+          {
+            name: tool[:function][:name],
+            description: tool[:function][:description],
+            input_schema: tool[:function][:parameters]
+          }
+        end
+      end
+
+      def format_response(response, model)
+        content = extract_content(response)
+
+        {
+          content: content,
+          raw: response,
+          model: model,
+          usage: {
+            prompt_tokens: response.dig('usage', 'input_tokens') || 0,
+            completion_tokens: response.dig('usage', 'output_tokens') || 0,
+            total_tokens: (response.dig('usage', 'input_tokens') || 0) + (response.dig('usage', 'output_tokens') || 0)
+          }
+        }
+      end
+
+      def extract_content(response)
+        # Handle different response formats
+        if response.is_a?(Hash)
+          # Direct API response
+          if response['content'].is_a?(Array)
+            response['content'].map { |c| c['text'] }.join
+          else
+            response['content'] || response['completion'] || ''
+          end
+        else
+          # Client wrapper response
+          response.content.first.text
+        end
+      rescue StandardError => e
+        Desiru.logger.error("Failed to extract content from Anthropic response: #{e.message}")
+        ''
+      end
+
+      def handle_api_error(error)
+        case error
+        when ::Faraday::UnauthorizedError
+          raise AuthenticationError, 'Invalid Anthropic API key'
+        when ::Faraday::BadRequestError
+          raise InvalidRequestError, "Invalid request: #{error.message}"
+        when ::Faraday::TooManyRequestsError
+          raise RateLimitError, 'Anthropic API rate limit exceeded'
+        else
+          raise APIError, "Anthropic API error: #{error.message}"
+        end
+      end
+    end
+  end
+end

data/lib/desiru/models/base.rb

@@ -16,9 +16,15 @@ module Desiru
         validate_config!
       end
 
-      # Main interface method - must be implemented by subclasses
+      # Main interface method - calls perform_completion with proper message formatting
       def complete(prompt, **options)
-        raise NotImplementedError, 'Subclasses must implement #complete'
+        messages = prepare_messages(prompt, options[:messages])
+
+        with_retry do
+          response = perform_completion(messages, options)
+          increment_stats(response[:usage][:total_tokens]) if response[:usage]
+          response
+        end
       end
 
       # Stream completion - optional implementation
@@ -59,7 +65,7 @@ module Desiru
         {
           model: nil,
           temperature: 0.7,
-          max_tokens: 1000,
+          max_tokens: 4096,
           timeout: 30,
           retry_on_failure: true,
           max_retries: 3
@@ -107,6 +113,34 @@ module Desiru
         jitter = rand(0..1.0)
         base_delay + jitter
       end
+
+      # Prepare messages in the expected format
+      def prepare_messages(prompt, additional_messages = nil)
+        messages = []
+
+        # Handle different prompt formats
+        case prompt
+        when String
+          messages << { role: 'user', content: prompt }
+        when Hash
+          messages << { role: 'system', content: prompt[:system] } if prompt[:system]
+          if prompt[:user]
+            messages << { role: 'user', content: prompt[:user] }
+          elsif prompt[:content]
+            messages << { role: 'user', content: prompt[:content] }
+          end
+        end
+
+        # Add any additional messages
+        messages.concat(additional_messages) if additional_messages
+
+        messages
+      end
+
+      # Subclasses must implement this method
+      def perform_completion(messages, options)
+        raise NotImplementedError, 'Subclasses must implement #perform_completion'
+      end
     end
   end
 end

data/lib/desiru/models/open_ai.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'openai'
+
+module Desiru
+  module Models
+    # OpenAI GPT model adapter
+    class OpenAI < Base
+      DEFAULT_MODEL = 'gpt-4o-mini'
+
+      def initialize(config = {})
+        super
+        @api_key = config[:api_key] || ENV.fetch('OPENAI_API_KEY', nil)
+        raise ArgumentError, 'OpenAI API key is required' unless @api_key
+
+        @client = ::OpenAI::Client.new(access_token: @api_key)
+        @models_cache = nil
+        @models_fetched_at = nil
+      end
+
+      def models
+        # Cache models for 1 hour
+        fetch_models if @models_cache.nil? || @models_fetched_at.nil? || (Time.now - @models_fetched_at) > 3600
+        @models_cache
+      end
+
+      protected
+
+      def perform_completion(messages, options)
+        model = options[:model] || @config[:model] || DEFAULT_MODEL
+        temperature = options[:temperature] || @config[:temperature] || 0.7
+        max_tokens = options[:max_tokens] || @config[:max_tokens] || 4096
+
+        # Prepare request parameters
+        params = {
+          model: model,
+          messages: messages,
+          temperature: temperature,
+          max_tokens: max_tokens
+        }
+
+        # Add response format if specified
+        params[:response_format] = options[:response_format] if options[:response_format]
+
+        # Add tools if provided
+        if options[:tools]
+          params[:tools] = options[:tools]
+          params[:tool_choice] = options[:tool_choice] if options[:tool_choice]
+        end
+
+        # Make API call
+        response = @client.chat(parameters: params)
+
+        # Format response
+        format_response(response, model)
+      rescue ::Faraday::Error => e
+        handle_api_error(e)
+      end
+
+      def stream_complete(prompt, **options, &block)
+        messages = prepare_messages(prompt, options[:messages])
+        model = options[:model] || @config[:model] || DEFAULT_MODEL
+        temperature = options[:temperature] || @config[:temperature] || 0.7
+        max_tokens = options[:max_tokens] || @config[:max_tokens] || 4096
+
+        # Prepare streaming request
+        params = {
+          model: model,
+          messages: messages,
+          temperature: temperature,
+          max_tokens: max_tokens,
+          stream: proc do |chunk, _bytesize|
+            # Extract content from chunk
+            if chunk.dig('choices', 0, 'delta', 'content')
+              content = chunk.dig('choices', 0, 'delta', 'content')
+              block.call(content) if block_given?
+            end
+          end
+        }
+
+        # Make streaming API call
+        @client.chat(parameters: params)
+      rescue ::Faraday::Error => e
+        handle_api_error(e)
+      end
+
+      private
+
+      def fetch_models
+        response = @client.models.list
+
+        @models_cache = {}
+        response['data'].each do |model|
+          # Filter for chat models only
+          next unless model['id'].include?('gpt') || model['id'].include?('o1')
+
+          @models_cache[model['id']] = {
+            name: model['id'],
+            created: model['created'],
+            owned_by: model['owned_by']
+          }
+        end
+
+        @models_fetched_at = Time.now
+        @models_cache
+      rescue StandardError => e
+        Desiru.logger.warn("Failed to fetch OpenAI models: #{e.message}")
+        # Fallback to commonly used models
+        @models_cache = {
+          'gpt-4o-mini' => { name: 'GPT-4o Mini' },
+          'gpt-4o' => { name: 'GPT-4o' },
+          'gpt-4-turbo' => { name: 'GPT-4 Turbo' },
+          'gpt-4' => { name: 'GPT-4' },
+          'gpt-3.5-turbo' => { name: 'GPT-3.5 Turbo' }
+        }
+        @models_fetched_at = Time.now
+        @models_cache
+      end
+
+      def format_response(response, model)
+        # Extract content and usage regardless of response structure
+        content = response.dig('choices', 0, 'message', 'content') || ''
+        usage = response['usage'] || {}
+
+        {
+          content: content,
+          raw: response,
+          model: model,
+          usage: {
+            prompt_tokens: usage['prompt_tokens'] || 0,
+            completion_tokens: usage['completion_tokens'] || 0,
+            total_tokens: usage['total_tokens'] || 0
+          }
+        }
+      end
+
+      def handle_api_error(error)
+        case error
+        when ::Faraday::UnauthorizedError
+          raise AuthenticationError, 'Invalid OpenAI API key'
+        when ::Faraday::BadRequestError
+          raise InvalidRequestError, "Invalid request: #{error.message}"
+        when ::Faraday::TooManyRequestsError
+          raise RateLimitError, 'OpenAI API rate limit exceeded'
+        else
+          raise APIError, "OpenAI API error: #{error.message}"
+        end
+      end
+    end
+  end
+end