rcrewai 0.1.0

data/lib/rcrewai/llm_clients/azure.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RCrewAI
+  module LLMClients
+    class Azure < Base
+      def initialize(config = RCrewAI.configuration)
+        super
+        @base_url = config.base_url || build_azure_url
+        @api_version = config.api_version || '2024-02-01'
+        @deployment_name = config.deployment_name || config.model
+      end
+
+      def chat(messages:, **options)
+        payload = {
+          messages: format_messages(messages),
+          temperature: options[:temperature] || config.temperature,
+          max_tokens: options[:max_tokens] || config.max_tokens
+        }
+
+        # Add additional OpenAI-compatible options
+        payload[:top_p] = options[:top_p] if options[:top_p]
+        payload[:frequency_penalty] = options[:frequency_penalty] if options[:frequency_penalty]
+        payload[:presence_penalty] = options[:presence_penalty] if options[:presence_penalty]
+        payload[:stop] = options[:stop] if options[:stop]
+
+        url = "#{@base_url}/openai/deployments/#{@deployment_name}/chat/completions?api-version=#{@api_version}"
+        log_request(:post, url, payload)
+
+        response = http_client.post(url, payload, build_headers.merge(authorization_header))
+        log_response(response)
+
+        result = handle_response(response)
+        format_response(result)
+      end
+
+      def complete(prompt:, **options)
+        # For older models that use completions endpoint
+        payload = {
+          prompt: prompt,
+          temperature: options[:temperature] || config.temperature,
+          max_tokens: options[:max_tokens] || config.max_tokens
+        }
+
+        url = "#{@base_url}/openai/deployments/#{@deployment_name}/completions?api-version=#{@api_version}"
+        log_request(:post, url, payload)
+
+        response = http_client.post(url, payload, build_headers.merge(authorization_header))
+        log_response(response)
+
+        result = handle_response(response)
+        format_completion_response(result)
+      end
+
+      def models
+        # Azure OpenAI uses deployments instead of models
+        url = "#{@base_url}/openai/deployments?api-version=#{@api_version}"
+        response = http_client.get(url, {}, build_headers.merge(authorization_header))
+        result = handle_response(response)
+        
+        if result['data']
+          result['data'].map { |deployment| deployment['id'] }
+        else
+          [@deployment_name].compact
+        end
+      end
+
+      private
+
+      def authorization_header
+        { 'api-key' => config.api_key }
+      end
+
+      def format_messages(messages)
+        messages.map do |msg|
+          if msg.is_a?(Hash)
+            msg
+          else
+            { role: 'user', content: msg.to_s }
+          end
+        end
+      end
+
+      def format_response(response)
+        choice = response.dig('choices', 0)
+        return nil unless choice
+
+        {
+          content: choice.dig('message', 'content'),
+          role: choice.dig('message', 'role'),
+          finish_reason: choice['finish_reason'],
+          usage: response['usage'],
+          model: @deployment_name,
+          provider: :azure
+        }
+      end
+
+      def format_completion_response(response)
+        choice = response.dig('choices', 0)
+        return nil unless choice
+
+        {
+          content: choice['text'],
+          finish_reason: choice['finish_reason'],
+          usage: response['usage'],
+          model: @deployment_name,
+          provider: :azure
+        }
+      end
+
+      def validate_config!
+        super
+        raise ConfigurationError, "Azure API key is required" unless config.azure_api_key || config.api_key
+        raise ConfigurationError, "Azure base URL or endpoint is required" unless config.base_url || azure_endpoint
+        raise ConfigurationError, "Azure deployment name is required" unless config.deployment_name || config.model
+      end
+
+      def build_azure_url
+        endpoint = azure_endpoint
+        return nil unless endpoint
+        
+        # Remove trailing slash and add proper path
+        endpoint = endpoint.chomp('/')
+        "#{endpoint}"
+      end
+
+      def azure_endpoint
+        # Try multiple environment variable names
+        ENV['AZURE_OPENAI_ENDPOINT'] || 
+        ENV['AZURE_ENDPOINT'] || 
+        config.instance_variable_get(:@azure_endpoint)
+      end
+
+      def handle_response(response)
+        case response.status
+        when 200..299
+          response.body
+        when 400
+          error_details = response.body.dig('error', 'message') || response.body
+          raise APIError, "Bad request: #{error_details}"
+        when 401
+          raise AuthenticationError, "Invalid API key or authentication failed"
+        when 403
+          raise AuthenticationError, "Access denied - check your API key and permissions"
+        when 404
+          raise ModelNotFoundError, "Deployment '#{@deployment_name}' not found"
+        when 429
+          raise RateLimitError, "Rate limit exceeded or quota exhausted"
+        when 500..599
+          raise APIError, "Azure OpenAI service error: #{response.status}"
+        else
+          raise APIError, "Unexpected response: #{response.status}"
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/llm_clients/base.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require 'logger'
+
+module RCrewAI
+  module LLMClients
+    class Base
+      attr_reader :config, :logger
+
+      def initialize(config = RCrewAI.configuration)
+        @config = config
+        @logger = Logger.new($stdout)
+        @logger.level = Logger::INFO
+        validate_config!
+      end
+
+      def chat(messages:, **options)
+        raise NotImplementedError, "Subclasses must implement #chat method"
+      end
+
+      def complete(prompt:, **options)
+        chat(messages: [{ role: 'user', content: prompt }], **options)
+      end
+
+      protected
+
+      def validate_config!
+        raise ConfigurationError, "API key is required" unless config.api_key
+        raise ConfigurationError, "Model is required" unless config.model
+      end
+
+      def build_headers
+        {
+          'Content-Type' => 'application/json',
+          'User-Agent' => "rcrewai/#{RCrewAI::VERSION}"
+        }
+      end
+
+      def http_client
+        @http_client ||= Faraday.new do |f|
+          f.request :json
+          f.response :json
+          f.adapter Faraday.default_adapter
+          f.options.timeout = config.timeout
+        end
+      end
+
+      def handle_response(response)
+        case response.status
+        when 200..299
+          response.body
+        when 400
+          raise APIError, "Bad request: #{response.body}"
+        when 401
+          raise AuthenticationError, "Invalid API key"
+        when 429
+          raise RateLimitError, "Rate limit exceeded"
+        when 500..599
+          raise APIError, "Server error: #{response.status}"
+        else
+          raise APIError, "Unexpected response: #{response.status}"
+        end
+      end
+
+      def log_request(method, url, payload = nil)
+        logger.info "#{method.upcase} #{url}"
+        logger.debug "Payload: #{payload}" if payload
+      end
+
+      def log_response(response)
+        logger.debug "Response: #{response.status} - #{response.body}"
+      end
+    end
+
+    class APIError < RCrewAI::Error; end
+    class AuthenticationError < APIError; end
+    class RateLimitError < APIError; end
+    class ModelNotFoundError < APIError; end
+  end
+end

data/lib/rcrewai/llm_clients/google.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RCrewAI
+  module LLMClients
+    class Google < Base
+      BASE_URL = 'https://generativelanguage.googleapis.com/v1beta'
+
+      def initialize(config = RCrewAI.configuration)
+        super
+        @base_url = BASE_URL
+      end
+
+      def chat(messages:, **options)
+        # Convert messages to Gemini format
+        formatted_contents = format_messages(messages)
+        
+        payload = {
+          contents: formatted_contents,
+          generationConfig: {
+            temperature: options[:temperature] || config.temperature,
+            maxOutputTokens: options[:max_tokens] || config.max_tokens || 2048,
+            topP: options[:top_p] || 0.8,
+            topK: options[:top_k] || 10
+          }
+        }
+
+        # Add safety settings if provided
+        if options[:safety_settings]
+          payload[:safetySettings] = options[:safety_settings]
+        end
+
+        # Add stop sequences if provided
+        if options[:stop_sequences]
+          payload[:generationConfig][:stopSequences] = options[:stop_sequences]
+        end
+
+        url = "#{@base_url}/models/#{config.model}:generateContent?key=#{config.api_key}"
+        log_request(:post, url, payload)
+
+        response = http_client.post(url, payload, build_headers)
+        log_response(response)
+
+        result = handle_response(response)
+        format_response(result)
+      end
+
+      def models
+        # Google AI Studio doesn't provide a models list endpoint with API key auth
+        # Return known Gemini models
+        [
+          'gemini-pro',
+          'gemini-pro-vision',
+          'gemini-1.5-pro',
+          'gemini-1.5-flash',
+          'text-bison-001',
+          'chat-bison-001'
+        ]
+      end
+
+      private
+
+      def format_messages(messages)
+        contents = []
+        
+        messages.each do |msg|
+          role = case msg[:role]
+                when 'user'
+                  'user'
+                when 'assistant'
+                  'model'
+                when 'system'
+                  # Gemini doesn't have system role, prepend to first user message
+                  next
+                else
+                  'user'
+                end
+
+          content = if msg.is_a?(Hash)
+                     msg[:content]
+                   else
+                     msg.to_s
+                   end
+
+          contents << {
+            role: role,
+            parts: [{ text: content }]
+          }
+        end
+
+        # Handle system message by prepending to first user message
+        system_msg = messages.find { |m| m[:role] == 'system' }
+        if system_msg && contents.any?
+          first_user_content = contents.find { |c| c[:role] == 'user' }
+          if first_user_content
+            original_text = first_user_content[:parts].first[:text]
+            first_user_content[:parts].first[:text] = "#{system_msg[:content]}\n\n#{original_text}"
+          end
+        end
+
+        contents
+      end
+
+      def format_response(response)
+        candidate = response.dig('candidates', 0)
+        return nil unless candidate
+
+        content = candidate.dig('content', 'parts', 0, 'text')
+        finish_reason = candidate['finishReason']
+
+        # Extract usage information if available
+        usage_metadata = response['usageMetadata']
+        usage = if usage_metadata
+                  {
+                    'prompt_tokens' => usage_metadata['promptTokenCount'],
+                    'completion_tokens' => usage_metadata['candidatesTokenCount'],
+                    'total_tokens' => usage_metadata['totalTokenCount']
+                  }
+                end
+
+        {
+          content: content,
+          role: 'assistant',
+          finish_reason: finish_reason,
+          usage: usage,
+          model: config.model,
+          provider: :google
+        }
+      end
+
+      def validate_config!
+        super
+        raise ConfigurationError, "Google API key is required" unless config.google_api_key || config.api_key
+      end
+
+      def handle_response(response)
+        case response.status
+        when 200..299
+          response.body
+        when 400
+          error_details = response.body.dig('error', 'message') || response.body
+          raise APIError, "Bad request: #{error_details}"
+        when 401
+          raise AuthenticationError, "Invalid API key"
+        when 403
+          raise AuthenticationError, "API key does not have permission"
+        when 429
+          raise RateLimitError, "Rate limit exceeded or quota exhausted"
+        when 500..599
+          raise APIError, "Server error: #{response.status}"
+        else
+          raise APIError, "Unexpected response: #{response.status}"
+        end
+      end
+    end
+  end
+end

data/lib/rcrewai/llm_clients/ollama.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RCrewAI
+  module LLMClients
+    class Ollama < Base
+      DEFAULT_URL = 'http://localhost:11434'
+
+      def initialize(config = RCrewAI.configuration)
+        super
+        @base_url = config.base_url || ollama_url || DEFAULT_URL
+      end
+
+      def chat(messages:, **options)
+        payload = {
+          model: config.model,
+          messages: format_messages(messages),
+          options: {
+            temperature: options[:temperature] || config.temperature,
+            num_predict: options[:max_tokens] || config.max_tokens,
+            top_p: options[:top_p],
+            top_k: options[:top_k],
+            repeat_penalty: options[:repeat_penalty]
+          }.compact
+        }
+
+        # Add stop sequences if provided
+        payload[:options][:stop] = options[:stop] if options[:stop]
+
+        url = "#{@base_url}/api/chat"
+        log_request(:post, url, payload)
+
+        response = http_client.post(url, payload, build_headers)
+        log_response(response)
+
+        result = handle_response(response)
+        format_response(result)
+      end
+
+      def complete(prompt:, **options)
+        payload = {
+          model: config.model,
+          prompt: prompt,
+          options: {
+            temperature: options[:temperature] || config.temperature,
+            num_predict: options[:max_tokens] || config.max_tokens,
+            top_p: options[:top_p],
+            top_k: options[:top_k],
+            repeat_penalty: options[:repeat_penalty]
+          }.compact
+        }
+
+        payload[:options][:stop] = options[:stop] if options[:stop]
+
+        url = "#{@base_url}/api/generate"
+        log_request(:post, url, payload)
+
+        response = http_client.post(url, payload, build_headers)
+        log_response(response)
+
+        result = handle_response(response)
+        format_completion_response(result)
+      end
+
+      def models
+        url = "#{@base_url}/api/tags"
+        response = http_client.get(url, {}, build_headers)
+        result = handle_response(response)
+        
+        if result['models']
+          result['models'].map { |model| model['name'] }
+        else
+          []
+        end
+      rescue => e
+        logger.warn "Failed to fetch Ollama models: #{e.message}"
+        []
+      end
+
+      def pull_model(model_name)
+        payload = { name: model_name }
+        url = "#{@base_url}/api/pull"
+        
+        response = http_client.post(url, payload, build_headers)
+        handle_response(response)
+      end
+
+      def model_info(model_name = nil)
+        model_name ||= config.model
+        payload = { name: model_name }
+        url = "#{@base_url}/api/show"
+        
+        response = http_client.post(url, payload, build_headers)
+        handle_response(response)
+      rescue => e
+        logger.warn "Failed to get model info for #{model_name}: #{e.message}"
+        nil
+      end
+
+      private
+
+      def format_messages(messages)
+        messages.map do |msg|
+          if msg.is_a?(Hash)
+            {
+              role: msg[:role],
+              content: msg[:content]
+            }
+          else
+            { role: 'user', content: msg.to_s }
+          end
+        end
+      end
+
+      def format_response(response)
+        message = response['message']
+        return nil unless message
+
+        # Ollama doesn't provide detailed usage stats by default
+        usage = {
+          'prompt_tokens' => response['prompt_eval_count'],
+          'completion_tokens' => response['eval_count'],
+          'total_tokens' => (response['prompt_eval_count'] || 0) + (response['eval_count'] || 0)
+        }.compact
+
+        {
+          content: message['content'],
+          role: message['role'] || 'assistant',
+          finish_reason: response['done'] ? 'stop' : nil,
+          usage: usage,
+          model: response['model'] || config.model,
+          provider: :ollama
+        }
+      end
+
+      def format_completion_response(response)
+        {
+          content: response['response'],
+          finish_reason: response['done'] ? 'stop' : nil,
+          usage: {
+            'prompt_tokens' => response['prompt_eval_count'],
+            'completion_tokens' => response['eval_count'],
+            'total_tokens' => (response['prompt_eval_count'] || 0) + (response['eval_count'] || 0)
+          }.compact,
+          model: response['model'] || config.model,
+          provider: :ollama
+        }
+      end
+
+      def validate_config!
+        # Ollama doesn't require an API key
+        raise ConfigurationError, "Model is required" unless config.model
+        
+        # Test connection to Ollama server
+        test_connection
+      end
+
+      def test_connection
+        url = "#{@base_url}/api/tags"
+        response = http_client.get(url, {}, build_headers)
+        
+        unless (200..299).include?(response.status)
+          raise ConfigurationError, "Cannot connect to Ollama server at #{@base_url}"
+        end
+      rescue Faraday::ConnectionFailed
+        raise ConfigurationError, "Cannot connect to Ollama server at #{@base_url}. Is Ollama running?"
+      end
+
+      def ollama_url
+        ENV['OLLAMA_HOST'] || ENV['OLLAMA_URL']
+      end
+
+      def build_headers
+        # Ollama doesn't require special headers
+        {
+          'Content-Type' => 'application/json',
+          'User-Agent' => "rcrewai/#{RCrewAI::VERSION}"
+        }
+      end
+
+      def handle_response(response)
+        case response.status
+        when 200..299
+          response.body
+        when 400
+          error_details = response.body['error'] || response.body
+          raise APIError, "Bad request: #{error_details}"
+        when 404
+          raise ModelNotFoundError, "Model '#{config.model}' not found. Try running: ollama pull #{config.model}"
+        when 500..599
+          raise APIError, "Ollama server error: #{response.status}"
+        else
+          raise APIError, "Unexpected response: #{response.status}"
+        end
+      end
+    end
+  end
+end