ruby_llm-agents 1.3.4 → 2.1.0

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

@@ -48,7 +48,6 @@ module RubyLLM
         @agents_by_type = {
           agent: @agents.select { |a| a[:agent_type] == "agent" },
           embedder: @agents.select { |a| a[:agent_type] == "embedder" },
-          moderator: @agents.select { |a| a[:agent_type] == "moderator" },
           speaker: @agents.select { |a| a[:agent_type] == "speaker" },
           transcriber: @agents.select { |a| a[:agent_type] == "transcriber" },
           image_generator: @agents.select { |a| a[:agent_type] == "image_generator" }
@@ -60,7 +59,7 @@ module RubyLLM
         Rails.logger.error("[RubyLLM::Agents] Error loading agents: #{e.message}")
         @agents = []
         @deleted_agents = []
-        @agents_by_type = { agent: [], embedder: [], moderator: [], speaker: [], transcriber: [], image_generator: [] }
+        @agents_by_type = { agent: [], embedder: [], speaker: [], transcriber: [], image_generator: [] }
         @agent_count = 0
         @deleted_count = 0
         @sort_params = { column: DEFAULT_AGENT_SORT_COLUMN, direction: DEFAULT_AGENT_SORT_DIRECTION }
@@ -119,13 +118,11 @@ module RubyLLM
       def load_filter_options
         # Single query to get all filter options (fixes N+1)
         filter_data = Execution.by_agent(@agent_type)
-                               .where.not(agent_version: nil)
-                               .or(Execution.by_agent(@agent_type).where.not(model_id: nil))
+                               .where.not(model_id: nil)
                                .or(Execution.by_agent(@agent_type).where.not(temperature: nil))
-                               .pluck(:agent_version, :model_id, :temperature)
+                               .pluck(:model_id, :temperature)
 
-        @versions = filter_data.map(&:first).compact.uniq.sort.reverse
-        @models = filter_data.map { |d| d[1] }.compact.uniq.sort
+        @models = filter_data.map(&:first).compact.uniq.sort
         @temperatures = filter_data.map(&:last).compact.uniq.sort
       end
 
@@ -149,7 +146,7 @@ module RubyLLM
 
       # Builds a filtered scope for the current agent's executions
       #
-      # Applies filters in order: status, version, model, temperature, time.
+      # Applies filters in order: status, model, temperature, time.
       # Each filter is optional and only applied if values are provided.
       #
       # @return [ActiveRecord::Relation] Filtered execution scope
@@ -160,10 +157,6 @@ module RubyLLM
         statuses = parse_array_param(:statuses)
         scope = apply_status_filter(scope, statuses) if statuses.any?
 
-        # Apply version filter
-        versions = parse_array_param(:versions)
-        scope = scope.where(agent_version: versions) if versions.any?
-
         # Apply model filter
         models = parse_array_param(:models)
         scope = scope.where(model_id: models) if models.any?
@@ -188,37 +181,6 @@ module RubyLLM
         @trend_data = Execution.trend_analysis(agent_type: @agent_type, days: 30)
         @status_distribution = Execution.by_agent(@agent_type).group(:status).count
         @finish_reason_distribution = Execution.by_agent(@agent_type).finish_reason_distribution
-        load_version_comparison
-      end
-
-      # Loads version comparison data if multiple versions exist
-      #
-      # Includes trend data for sparkline charts.
-      #
-      # @return [void]
-      def load_version_comparison
-        return unless @versions.size >= 2
-
-        # Default to comparing two most recent versions
-        v1 = params[:compare_v1] || @versions[0]
-        v2 = params[:compare_v2] || @versions[1]
-
-        comparison_data = Execution.compare_versions(@agent_type, v1, v2, period: :this_month)
-
-        # Fetch trend data for sparklines
-        v1_trend = Execution.version_trend_data(@agent_type, v1, days: 14)
-        v2_trend = Execution.version_trend_data(@agent_type, v2, days: 14)
-
-        @version_comparison = {
-          v1: v1,
-          v2: v2,
-          data: comparison_data,
-          v1_trend: v1_trend,
-          v2_trend: v2_trend
-        }
-      rescue StandardError => e
-        Rails.logger.debug("[RubyLLM::Agents] Version comparison error: #{e.message}")
-        @version_comparison = nil
       end
 
       # Loads the current agent class configuration
@@ -234,7 +196,6 @@ module RubyLLM
         # Common config for all types
         @config = {
           model: safe_config_call(:model),
-          version: safe_config_call(:version) || "N/A",
           description: safe_config_call(:description)
         }
 
@@ -242,8 +203,6 @@ module RubyLLM
         case @agent_type_kind
         when "embedder"
           load_embedder_config
-        when "moderator"
-          load_moderator_config
         when "speaker"
           load_speaker_config
         when "transcriber"
@@ -284,16 +243,6 @@ module RubyLLM
         )
       end
 
-      # Loads configuration specific to Moderators
-      #
-      # @return [void]
-      def load_moderator_config
-        @config.merge!(
-          threshold: safe_config_call(:threshold),
-          categories: safe_config_call(:categories)
-        )
-      end
-
       # Loads configuration specific to Speakers
       #
       # @return [void]

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

@@ -32,37 +32,11 @@ module RubyLLM
 
       # Returns chart data as JSON for live updates
       #
-      # @param range [String] Time range: "today", "7d", "30d", "60d", "90d", or custom "YYYY-MM-DD_YYYY-MM-DD"
-      # @param compare [String] If "true", include comparison data from previous period
-      # @return [JSON] Chart data with series (and optional comparison series)
+      # @param range [String] Time range: "today", "7d", or "30d"
+      # @return [JSON] Chart data with series
       def chart_data
         range = params[:range].presence || "today"
-        compare = params[:compare] == "true"
-
-        if custom_range?(range)
-          from_date, to_date = parse_custom_range(range)
-          data = tenant_scoped_executions.activity_chart_json_for_dates(from: from_date, to: to_date)
-        else
-          data = tenant_scoped_executions.activity_chart_json(range: range)
-        end
-
-        if compare
-          offset_days = range_to_days(range)
-          comparison_data = if custom_range?(range)
-            from_date, to_date = parse_custom_range(range)
-            tenant_scoped_executions.activity_chart_json_for_dates(
-              from: from_date - offset_days.days,
-              to: to_date - offset_days.days
-            )
-          else
-            tenant_scoped_executions.activity_chart_json(
-              range: range,
-              offset_days: offset_days
-            )
-          end
-          data[:comparison] = comparison_data
-        end
-
+        data = tenant_scoped_executions.activity_chart_json(range: range)
         render json: data
       end
 
@@ -70,49 +44,17 @@ module RubyLLM
 
       # Converts range parameter to number of days
       #
-      # @param range [String] Range parameter (today, 7d, 30d, 60d, 90d, or custom YYYY-MM-DD_YYYY-MM-DD)
+      # @param range [String] Range parameter (today, 7d, 30d)
       # @return [Integer] Number of days
       def range_to_days(range)
         case range
         when "today" then 1
         when "7d" then 7
         when "30d" then 30
-        when "60d" then 60
-        when "90d" then 90
-        else
-          # Handle custom range format "YYYY-MM-DD_YYYY-MM-DD"
-          if range&.include?("_")
-            from_str, to_str = range.split("_")
-            from_date = Date.parse(from_str) rescue nil
-            to_date = Date.parse(to_str) rescue nil
-            if from_date && to_date
-              (to_date - from_date).to_i + 1
-            else
-              1
-            end
-          else
-            1
-          end
+        else 1
         end
       end
 
-      # Checks if a range is a custom date range
-      #
-      # @param range [String] Range parameter
-      # @return [Boolean] True if custom date range format
-      def custom_range?(range)
-        range&.match?(/\A\d{4}-\d{2}-\d{2}_\d{4}-\d{2}-\d{2}\z/)
-      end
-
-      # Parses a custom range string into date objects
-      #
-      # @param range [String] Custom range in format "YYYY-MM-DD_YYYY-MM-DD"
-      # @return [Array<Date>] [from_date, to_date]
-      def parse_custom_range(range)
-        from_str, to_str = range.split("_")
-        [Date.parse(from_str), Date.parse(to_str)]
-      end
-
       # Builds per-agent comparison statistics for all agent types
       #
       # Creates separate instance variables for each agent type:
@@ -121,8 +63,6 @@ module RubyLLM
       # - @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 base agent stats (for backward compatibility)
@@ -138,7 +78,6 @@ module RubyLLM
         all_stats = all_agent_types.map do |agent_type|
           agent_class = AgentRegistry.find(agent_type)
           detected_type = AgentRegistry.send(:detect_agent_type, agent_class)
-          workflow_type = detected_type == "workflow" ? detect_workflow_type(agent_class) : nil
 
           # Get stats from batch or use zeros for never-executed agents
           stats = execution_stats[agent_type] || {
@@ -152,43 +91,21 @@ module RubyLLM
             total_cost: stats[:total_cost],
             avg_cost: stats[:avg_cost],
             avg_duration_ms: stats[:avg_duration_ms],
-            success_rate: stats[:success_rate],
-            is_workflow: detected_type == "workflow",
-            workflow_type: workflow_type
+            success_rate: stats[:success_rate]
           }
         end.sort_by { |a| [-(a[:executions] || 0), -(a[:total_cost] || 0)] }
 
-        # Split stats by agent type for 7-tab display
+        # Split stats by agent type for 5-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
-      #
-      # @param agent_class [Class] The agent class
-      # @return [String, nil] "pipeline", "parallel", "router", or nil
-      def detect_workflow_type(agent_class)
-        return nil unless agent_class
-
-        ancestors = agent_class.ancestors.map { |a| a.name.to_s }
-
-        if ancestors.include?("RubyLLM::Agents::Workflow::Pipeline")
-          "pipeline"
-        elsif ancestors.include?("RubyLLM::Agents::Workflow::Parallel")
-          "parallel"
-        elsif ancestors.include?("RubyLLM::Agents::Workflow::Router")
-          "router"
-        end
-      end
-
       # Builds per-model statistics for model comparison and cost breakdown
       #
       # @param base_scope [ActiveRecord::Relation] Base scope to filter from
@@ -337,34 +254,33 @@ module RubyLLM
         []
       end
 
-      # Loads tenant budget info for the current tenant
+      # Loads tenant budget info for the current tenant using counter columns
       #
-      # @param base_scope [ActiveRecord::Relation] Base scope for usage calculation
+      # @param base_scope [ActiveRecord::Relation] Base scope (unused, kept for backward compat)
       # @return [Hash, nil] Tenant budget data with usage info, or nil if not applicable
       def load_tenant_budget(base_scope)
         return nil unless tenant_filter_enabled? && current_tenant_id.present?
-        return nil unless TenantBudget.table_exists?
+        return nil unless Tenant.table_exists?
 
-        budget = TenantBudget.for_tenant(current_tenant_id)
-        return nil unless budget
+        tenant = Tenant.for(current_tenant_id)
+        return nil unless tenant
 
-        # Calculate current usage
-        today_scope = base_scope.where("created_at >= ?", Time.current.beginning_of_day)
-        month_scope = base_scope.where("created_at >= ?", Time.current.beginning_of_month)
+        tenant.ensure_daily_reset!
+        tenant.ensure_monthly_reset!
 
-        daily_spend = today_scope.sum(:total_cost) || 0
-        monthly_spend = month_scope.sum(:total_cost) || 0
+        daily_spend = tenant.daily_cost_spent
+        monthly_spend = tenant.monthly_cost_spent
 
         {
           tenant_id: current_tenant_id,
-          daily_limit: budget.effective_daily_limit,
-          monthly_limit: budget.effective_monthly_limit,
+          daily_limit: tenant.effective_daily_limit,
+          monthly_limit: tenant.effective_monthly_limit,
           daily_spend: daily_spend,
           monthly_spend: monthly_spend,
-          daily_percentage: budget.effective_daily_limit.to_f > 0 ? (daily_spend / budget.effective_daily_limit * 100).round(1) : 0,
-          monthly_percentage: budget.effective_monthly_limit.to_f > 0 ? (monthly_spend / budget.effective_monthly_limit * 100).round(1) : 0,
-          enforcement: budget.effective_enforcement,
-          per_agent_daily: budget.per_agent_daily || {}
+          daily_percentage: tenant.effective_daily_limit.to_f > 0 ? (daily_spend / tenant.effective_daily_limit * 100).round(1) : 0,
+          monthly_percentage: tenant.effective_monthly_limit.to_f > 0 ? (monthly_spend / tenant.effective_monthly_limit * 100).round(1) : 0,
+          enforcement: tenant.effective_enforcement,
+          per_agent_daily: tenant.per_agent_daily || {}
         }
       end
 

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

@@ -16,7 +16,7 @@ module RubyLLM
       include Filterable
       include Sortable
 
-      CSV_COLUMNS = %w[id agent_type agent_version status model_id total_tokens total_cost
+      CSV_COLUMNS = %w[id agent_type status model_id total_tokens total_cost
                        duration_ms created_at error_class error_message].freeze
 
       # Lists all executions with filtering and pagination
@@ -61,49 +61,6 @@ module RubyLLM
         end
       end
 
-      # Reruns an execution with the same parameters
-      #
-      # Supports both dry-run mode (returns prompt info without API call)
-      # and real reruns that create a new execution.
-      #
-      # @return [void]
-      def rerun
-        @execution = Execution.find(params[:id])
-        dry_run = params[:dry_run] == "true"
-
-        agent_class = AgentRegistry.find(@execution.agent_type)
-
-        unless agent_class
-          flash[:alert] = "Agent class '#{@execution.agent_type}' not found. Cannot rerun."
-          redirect_to execution_path(@execution)
-          return
-        end
-
-        # Prepare parameters from original execution
-        original_params = @execution.parameters&.symbolize_keys || {}
-
-        if dry_run
-          # Dry run mode - show what would be sent without making API call
-          result = agent_class.call(**original_params, dry_run: true)
-          @dry_run_result = result
-
-          respond_to do |format|
-            format.html { render :dry_run }
-            format.json { render json: result }
-          end
-        else
-          # Real rerun - execute the agent
-          begin
-            agent_class.call(**original_params)
-            flash[:notice] = "Execution rerun successfully! Check the executions list for the new result."
-          rescue StandardError => e
-            flash[:alert] = "Rerun failed: #{e.message}"
-          end
-
-          redirect_to executions_path
-        end
-      end
-
       # Exports filtered executions as CSV
       #
       # Streams CSV data with redacted error messages to protect
@@ -141,7 +98,6 @@ module RubyLLM
         CSV.generate_line([
           execution.id,
           execution.agent_type,
-          execution.agent_version,
           execution.status,
           execution.model_id,
           execution.total_tokens,
@@ -156,14 +112,12 @@ module RubyLLM
       # Loads available options for filter dropdowns
       #
       # Populates @agent_types with all agent types that have executions,
-      # @model_ids with all distinct models used, @workflow_types with
-      # workflow patterns used, and @statuses with all possible status values.
+      # @model_ids with all distinct models used, and @statuses with all possible status values.
       #
       # @return [void]
       def load_filter_options
         @agent_types = available_agent_types
         @model_ids = available_model_ids
-        @workflow_types = available_workflow_types
         @statuses = Execution.statuses.keys
       end
 
@@ -187,24 +141,6 @@ module RubyLLM
         @available_model_ids ||= tenant_scoped_executions.where.not(model_id: nil).distinct.pluck(:model_id).sort
       end
 
-      # Returns distinct workflow types from execution history
-      #
-      # Memoized to avoid duplicate queries within a request.
-      # Returns empty array if workflow_type column doesn't exist yet.
-      # Uses tenant_scoped_executions to respect multi-tenancy filtering.
-      #
-      # @return [Array<String>] Workflow types (pipeline, parallel, router)
-      def available_workflow_types
-        return @available_workflow_types if defined?(@available_workflow_types)
-
-        @available_workflow_types = if Execution.column_names.include?("workflow_type")
-                                      tenant_scoped_executions.where.not(workflow_type: [nil, ""])
-                                                              .distinct.pluck(:workflow_type).sort
-                                    else
-                                      []
-                                    end
-      end
-
       # Loads paginated executions and associated statistics
       #
       # Sets @executions, @pagination, @sort_params, and @filter_stats instance variables
@@ -264,63 +200,17 @@ module RubyLLM
         model_ids = parse_array_param(:model_ids)
         scope = scope.where(model_id: model_ids) if model_ids.any?
 
-        # Apply workflow type filter (only if column exists)
-        if Execution.column_names.include?("workflow_type")
-          workflow_types = parse_array_param(:workflow_types)
-          if workflow_types.any?
-            includes_single = workflow_types.include?("single")
-            other_types = workflow_types - ["single"]
-
-            if includes_single && other_types.any?
-              # Include both single (null workflow_type) and specific workflow types
-              scope = scope.where(workflow_type: [nil, ""] + other_types)
-            elsif includes_single
-              # Only single executions (non-workflow)
-              scope = scope.where(workflow_type: [nil, ""])
-            else
-              # Only specific workflow types
-              scope = scope.where(workflow_type: workflow_types)
-            end
-          end
-        end
-
-        # Apply execution type tab filter (agents vs workflows)
-        scope = apply_execution_type_filter(scope)
-
         # Apply retries filter (show only executions with multiple attempts)
         scope = scope.where("attempts_count > 1") if params[:has_retries].present?
 
-        # Only show root executions (not workflow children) - children are nested under parents
+        # Only show root executions - children are nested under parents
         scope = scope.where(parent_execution_id: nil)
 
-        # Eager load children for workflow grouping
+        # Eager load children for grouping
         scope = scope.includes(:child_executions)
 
         scope
       end
-
-      # Applies execution type filter (all, agents, workflows, or specific workflow type)
-      #
-      # @param scope [ActiveRecord::Relation] The current scope
-      # @return [ActiveRecord::Relation] Filtered scope
-      def apply_execution_type_filter(scope)
-        return scope unless Execution.column_names.include?("workflow_type")
-
-        execution_type = params[:execution_type]
-        case execution_type
-        when "agents"
-          # Only show executions where workflow_type is null/empty (regular agents)
-          scope.where(workflow_type: [nil, ""])
-        when "workflows"
-          # Only show executions with a workflow_type (any workflow)
-          scope.where.not(workflow_type: [nil, ""])
-        when "pipeline", "parallel", "router"
-          # Show specific workflow type
-          scope.where(workflow_type: execution_type)
-        else
-          scope
-        end
-      end
     end
   end
 end

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

@@ -10,11 +10,26 @@ module RubyLLM
     # @see TenantBudget For budget configuration model
     # @api private
     class TenantsController < ApplicationController
-      # Lists all tenant budgets
+      TENANT_SORTABLE_COLUMNS = %w[name enforcement daily_limit monthly_limit].freeze
+      DEFAULT_TENANT_SORT_COLUMN = "name"
+      DEFAULT_TENANT_SORT_DIRECTION = "asc"
+
+      # Lists all tenant budgets with optional search and sorting
       #
       # @return [void]
       def index
-        @tenants = TenantBudget.order(:name, :tenant_id)
+        @sort_params = parse_tenant_sort_params
+        scope = TenantBudget.all
+
+        if params[:q].present?
+          @search_query = params[:q].to_s.strip
+          scope = scope.where(
+            "tenant_id LIKE :q OR name LIKE :q",
+            q: "%#{TenantBudget.sanitize_sql_like(@search_query)}%"
+          )
+        end
+
+        @tenants = scope.order(@sort_params[:column] => @sort_params[:direction].to_sym)
       end
 
       # Shows a single tenant's budget details
@@ -95,6 +110,19 @@ module RubyLLM
         }
       end
 
+      # Parses and validates sort parameters for tenants list
+      #
+      # @return [Hash] Contains :column and :direction keys
+      def parse_tenant_sort_params
+        column = params[:sort].to_s
+        direction = params[:direction].to_s.downcase
+
+        {
+          column: TENANT_SORTABLE_COLUMNS.include?(column) ? column : DEFAULT_TENANT_SORT_COLUMN,
+          direction: %w[asc desc].include?(direction) ? direction : DEFAULT_TENANT_SORT_DIRECTION
+        }
+      end
+
       # Calculates percentage used
       #
       # @param current [Numeric] Current usage