ruby_llm-agents 0.4.0 → 1.0.0.beta.1

data/app/controllers/ruby_llm/agents/api_configurations_controller.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Controller for managing API configurations
+    #
+    # Provides CRUD operations for global and tenant-specific API
+    # configurations, including API keys and connection settings.
+    #
+    # @see ApiConfiguration
+    # @api private
+    class ApiConfigurationsController < ApplicationController
+      before_action :ensure_table_exists
+      before_action :set_global_config, only: [:show, :edit, :update]
+      before_action :set_tenant_config, only: [:tenant, :edit_tenant, :update_tenant]
+
+      # Displays the global API configuration
+      #
+      # @return [void]
+      def show
+        @resolved = ApiConfiguration.resolve
+        @provider_statuses = @resolved.provider_statuses_with_source
+      end
+
+      # Renders the edit form for global configuration
+      #
+      # @return [void]
+      def edit
+        @resolved = ApiConfiguration.resolve
+      end
+
+      # Updates the global API configuration
+      #
+      # @return [void]
+      def update
+        if @config.update(api_configuration_params)
+          log_configuration_change(@config, "global")
+          redirect_to edit_api_configuration_path, notice: "API configuration updated successfully"
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      # Displays tenant-specific API configuration
+      #
+      # @return [void]
+      def tenant
+        @resolved = ApiConfiguration.resolve(tenant_id: params[:tenant_id])
+        @provider_statuses = @resolved.provider_statuses_with_source
+        @tenant_budget = TenantBudget.for_tenant(params[:tenant_id])
+      end
+
+      # Renders the edit form for tenant configuration
+      #
+      # @return [void]
+      def edit_tenant
+        @resolved = ApiConfiguration.resolve(tenant_id: @tenant_id)
+      end
+
+      # Updates a tenant-specific API configuration
+      #
+      # @return [void]
+      def update_tenant
+        if @config.update(api_configuration_params)
+          log_configuration_change(@config, "tenant:#{params[:tenant_id]}")
+          redirect_to edit_tenant_api_configuration_path(params[:tenant_id]),
+                      notice: "Tenant API configuration updated successfully"
+        else
+          render :edit_tenant, status: :unprocessable_entity
+        end
+      end
+
+      # Tests API key validity for a specific provider
+      # (Optional - can be used for AJAX validation)
+      #
+      # @return [void]
+      def test_connection
+        provider = params[:provider]
+        api_key = params[:api_key]
+
+        result = test_provider_connection(provider, api_key)
+
+        render json: {
+          success: result[:success],
+          message: result[:message],
+          models: result[:models]
+        }
+      rescue StandardError => e
+        render json: { success: false, message: e.message }
+      end
+
+      private
+
+      # Ensures the api_configurations table exists
+      def ensure_table_exists
+        return if ApiConfiguration.table_exists?
+
+        flash[:alert] = "API configurations table not found. Run the generator: rails generate ruby_llm_agents:api_configuration"
+        redirect_to root_path
+      end
+
+      # Sets the global configuration (creates if not exists)
+      def set_global_config
+        @config = ApiConfiguration.global
+      end
+
+      # Sets the tenant-specific configuration (creates if not exists)
+      def set_tenant_config
+        @tenant_id = params[:tenant_id]
+        raise ActionController::RoutingError, "Tenant ID required" if @tenant_id.blank?
+
+        @config = ApiConfiguration.for_tenant!(@tenant_id)
+      end
+
+      # Strong parameters for API configuration
+      #
+      # @return [ActionController::Parameters]
+      def api_configuration_params
+        params.require(:api_configuration).permit(
+          # API Keys
+          :openai_api_key,
+          :anthropic_api_key,
+          :gemini_api_key,
+          :deepseek_api_key,
+          :mistral_api_key,
+          :perplexity_api_key,
+          :openrouter_api_key,
+          :gpustack_api_key,
+          :xai_api_key,
+          :ollama_api_key,
+          # AWS Bedrock
+          :bedrock_api_key,
+          :bedrock_secret_key,
+          :bedrock_session_token,
+          :bedrock_region,
+          # Vertex AI
+          :vertexai_credentials,
+          :vertexai_project_id,
+          :vertexai_location,
+          # Endpoints
+          :openai_api_base,
+          :gemini_api_base,
+          :ollama_api_base,
+          :gpustack_api_base,
+          :xai_api_base,
+          # OpenAI Options
+          :openai_organization_id,
+          :openai_project_id,
+          # Default Models
+          :default_model,
+          :default_embedding_model,
+          :default_image_model,
+          :default_moderation_model,
+          # Connection Settings
+          :request_timeout,
+          :max_retries,
+          :retry_interval,
+          :retry_backoff_factor,
+          :retry_interval_randomness,
+          :http_proxy,
+          # Inheritance
+          :inherit_global_defaults
+        ).tap do |permitted|
+          # Remove blank API keys to prevent overwriting with empty values
+          # This allows users to submit forms without touching existing keys
+          ApiConfiguration::API_KEY_ATTRIBUTES.each do |key|
+            permitted.delete(key) if permitted[key].blank?
+          end
+        end
+      end
+
+      # Logs configuration changes for audit purposes
+      #
+      # @param config [ApiConfiguration] The configuration that changed
+      # @param scope [String] The scope identifier
+      def log_configuration_change(config, scope)
+        changed_fields = config.previous_changes.keys.reject { |k| k.end_with?("_at") }
+        return if changed_fields.empty?
+
+        # Mask sensitive fields in the log
+        masked_changes = changed_fields.map do |field|
+          if field.include?("api_key") || field.include?("secret") || field.include?("credentials")
+            "#{field}: [REDACTED]"
+          else
+            "#{field}: #{config.previous_changes[field].last}"
+          end
+        end
+
+        Rails.logger.info(
+          "[RubyLLM::Agents] API configuration updated for #{scope}: #{masked_changes.join(', ')}"
+        )
+      end
+
+      # Tests connection to a specific provider
+      #
+      # @param provider [String] Provider key
+      # @param api_key [String] API key to test
+      # @return [Hash] Test result with success, message, and models
+      def test_provider_connection(provider, api_key)
+        # This is a placeholder - actual implementation would depend on
+        # RubyLLM's ability to list models or make a test request
+        case provider
+        when "openai"
+          # Example: Try to list models
+          { success: true, message: "Connection successful", models: [] }
+        when "anthropic"
+          { success: true, message: "Connection successful", models: [] }
+        else
+          { success: false, message: "Provider not supported for testing" }
+        end
+      end
+    end
+  end
+end

data/app/controllers/ruby_llm/agents/dashboard_controller.rb

@@ -53,10 +53,19 @@ module RubyLLM
         end
       end
 
-      # Builds per-agent comparison statistics
+      # Builds per-agent comparison statistics for all agent types
+      #
+      # Creates separate instance variables for each agent type:
+      # - @agent_stats: Base agents
+      # - @embedder_stats: Embedders
+      # - @transcriber_stats: Transcribers
+      # - @speaker_stats: Speakers
+      # - @image_generator_stats: Image generators
+      # - @moderator_stats: Moderators
+      # - @workflow_stats: Workflows
       #
       # @param base_scope [ActiveRecord::Relation] Base scope to filter from
-      # @return [Array<Hash>] Array of all stats sorted by cost descending
+      # @return [Array<Hash>] Array of base agent stats (for backward compatibility)
       def build_agent_comparison(base_scope = Execution)
         scope = base_scope.last_n_days(@days)
         agent_types = scope.distinct.pluck(:agent_type)
@@ -67,26 +76,37 @@ module RubyLLM
           total_cost = agent_scope.sum(:total_cost) || 0
           successful = agent_scope.successful.count
 
-          # Detect if this is a workflow
+          # Detect agent type using AgentRegistry
           agent_class = AgentRegistry.find(agent_type)
-          is_workflow = agent_class&.ancestors&.any? { |a| a.name&.include?("Workflow") }
-          workflow_type = is_workflow ? detect_workflow_type(agent_class) : nil
+          detected_type = AgentRegistry.send(:detect_agent_type, agent_class)
+
+          # Get workflow type if applicable
+          workflow_type = detected_type == "workflow" ? detect_workflow_type(agent_class) : nil
 
           {
             agent_type: agent_type,
+            detected_type: detected_type,
             executions: count,
             total_cost: total_cost,
             avg_cost: count > 0 ? (total_cost / count).round(6) : 0,
             avg_duration_ms: agent_scope.average(:duration_ms)&.round || 0,
             success_rate: count > 0 ? (successful.to_f / count * 100).round(1) : 0,
-            is_workflow: is_workflow,
+            is_workflow: detected_type == "workflow",
             workflow_type: workflow_type
           }
         end.sort_by { |a| -(a[:total_cost] || 0) }
 
-        # Split into agents and workflows for tabbed display
-        @workflow_stats = all_stats.select { |a| a[:is_workflow] }
-        all_stats.reject { |a| a[:is_workflow] }
+        # Split stats by agent type for 7-tab display
+        @agent_stats = all_stats.select { |a| a[:detected_type] == "agent" }
+        @embedder_stats = all_stats.select { |a| a[:detected_type] == "embedder" }
+        @transcriber_stats = all_stats.select { |a| a[:detected_type] == "transcriber" }
+        @speaker_stats = all_stats.select { |a| a[:detected_type] == "speaker" }
+        @image_generator_stats = all_stats.select { |a| a[:detected_type] == "image_generator" }
+        @moderator_stats = all_stats.select { |a| a[:detected_type] == "moderator" }
+        @workflow_stats = all_stats.select { |a| a[:detected_type] == "workflow" }
+
+        # Return base agents for backward compatibility
+        @agent_stats
       end
 
       # Detects workflow type from class hierarchy

data/app/controllers/ruby_llm/agents/{settings_controller.rb → system_config_controller.rb}

@@ -2,14 +2,14 @@
 
 module RubyLLM
   module Agents
-    # Controller for displaying global configuration settings
+    # Controller for displaying system configuration
     #
     # Shows all configuration options from RubyLLM::Agents.configuration
     # in a read-only dashboard view.
     #
     # @api private
-    class SettingsController < ApplicationController
-      # Displays the global configuration settings
+    class SystemConfigController < ApplicationController
+      # Displays the system configuration
       #
       # @return [void]
       def show

data/app/controllers/ruby_llm/agents/tenants_controller.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Controller for managing tenant budgets
+    #
+    # Provides CRUD operations for viewing and editing tenant budget
+    # configurations, including cost limits and token limits.
+    #
+    # @see TenantBudget For budget configuration model
+    # @api private
+    class TenantsController < ApplicationController
+      # Lists all tenant budgets
+      #
+      # @return [void]
+      def index
+        @tenants = TenantBudget.order(:name, :tenant_id)
+      end
+
+      # Shows a single tenant's budget details
+      #
+      # @return [void]
+      def show
+        @tenant = TenantBudget.find(params[:id])
+        @executions = tenant_executions(@tenant.tenant_id).recent.limit(10)
+        @usage_stats = calculate_usage_stats(@tenant)
+      end
+
+      # Renders the edit form for a tenant budget
+      #
+      # @return [void]
+      def edit
+        @tenant = TenantBudget.find(params[:id])
+      end
+
+      # Updates a tenant budget
+      #
+      # @return [void]
+      def update
+        @tenant = TenantBudget.find(params[:id])
+        if @tenant.update(tenant_params)
+          redirect_to tenant_path(@tenant), notice: "Tenant updated successfully"
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      # Strong parameters for tenant budget
+      #
+      # @return [ActionController::Parameters] Permitted parameters
+      def tenant_params
+        params.require(:tenant_budget).permit(
+          :name, :daily_limit, :monthly_limit,
+          :daily_token_limit, :monthly_token_limit,
+          :enforcement
+        )
+      end
+
+      # Returns executions scoped to a specific tenant
+      #
+      # @param tenant_id [String] The tenant identifier
+      # @return [ActiveRecord::Relation] Executions for the tenant
+      def tenant_executions(tenant_id)
+        Execution.by_tenant(tenant_id)
+      end
+
+      # Calculates usage statistics for a tenant
+      #
+      # @param tenant [TenantBudget] The tenant budget record
+      # @return [Hash] Usage statistics
+      def calculate_usage_stats(tenant)
+        scope = tenant_executions(tenant.tenant_id)
+        today_scope = scope.where("created_at >= ?", Time.current.beginning_of_day)
+        month_scope = scope.where("created_at >= ?", Time.current.beginning_of_month)
+
+        daily_spend = today_scope.sum(:total_cost) || 0
+        monthly_spend = month_scope.sum(:total_cost) || 0
+        daily_tokens = today_scope.sum(:total_tokens) || 0
+        monthly_tokens = month_scope.sum(:total_tokens) || 0
+
+        {
+          daily_spend: daily_spend,
+          monthly_spend: monthly_spend,
+          daily_tokens: daily_tokens,
+          monthly_tokens: monthly_tokens,
+          daily_spend_percentage: percentage_used(daily_spend, tenant.effective_daily_limit),
+          monthly_spend_percentage: percentage_used(monthly_spend, tenant.effective_monthly_limit),
+          daily_token_percentage: percentage_used(daily_tokens, tenant.effective_daily_token_limit),
+          monthly_token_percentage: percentage_used(monthly_tokens, tenant.effective_monthly_token_limit),
+          total_executions: scope.count,
+          total_cost: scope.sum(:total_cost) || 0,
+          total_tokens: scope.sum(:total_tokens) || 0
+        }
+      end
+
+      # Calculates percentage used
+      #
+      # @param current [Numeric] Current usage
+      # @param limit [Numeric, nil] The limit
+      # @return [Float] Percentage used (0-100+)
+      def percentage_used(current, limit)
+        return 0 if limit.nil? || limit.to_f <= 0
+        (current.to_f / limit.to_f * 100).round(1)
+      end
+    end
+  end
+end