ruby_llm-agents 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c1293e62ffc0a0799831f2327238fe2929cc3c72aaf036f515b92133b8dcd70
-  data.tar.gz: 885598b5c419ed497e118559ef79513df1b4ad85fcc16ce26356ebf5d365a02d
+  metadata.gz: a14dc618496842dd6db2fc197ab5c4f4190fb635b1bad8765a0983cc00e2550d
+  data.tar.gz: 22132d6e59964206dccb41db60dd3a9939217d47d6925074523bc1027173f4ed
 SHA512:
-  metadata.gz: ef4a8745a5b182721cecb6cdc56656b4aa6a6fee25cef2cb82d208385fcee9cacfd8f5b23897d1332ec7fb1cdc0e44696bff34659f4b9cef39807e267e07d767
-  data.tar.gz: 3736fbc6e8106a9e0a0eb6a56c9b9b1ae0e567520bb63622ad027449940fe465c2f1f101b05d4c83874f506119ed326db661313649dc52adfed69d6e69c28550
+  metadata.gz: c4936cf3773b4864bb9d1dd8031fb23e8321435bc4c1730ac088f299cc60f5a88992496b317f3391a131a303a6c82666ca7c4d1b77e4ea7da2f8c033e01a8c43
+  data.tar.gz: ca34cddc439b2f80652f9748dc62bd5fa1d365feac68101f7567e15f1bc5c2fef4dcec97e552b1dde7a20744782143c1ef5bffc2c7aaa97083b7d2f36bcf600c

data/app/controllers/concerns/ruby_llm/agents/paginatable.rb

@@ -21,6 +21,7 @@ module RubyLLM
       #
       # @param scope [ActiveRecord::Relation] The scope to paginate
       # @param ordered [Boolean] Whether to apply default descending order (default: true)
+      # @param sort_params [Hash, nil] Optional custom sort parameters with :column and :direction
       # @return [Hash] Contains :records and :pagination keys
       # @option return [ActiveRecord::Relation] :records Paginated records
       # @option return [Hash] :pagination Pagination metadata
@@ -28,13 +29,18 @@ module RubyLLM
       #   - :per_page [Integer] Records per page
       #   - :total_count [Integer] Total record count
       #   - :total_pages [Integer] Total page count
-      def paginate(scope, ordered: true)
+      def paginate(scope, ordered: true, sort_params: nil)
         page = [(params[:page] || 1).to_i, 1].max
         per_page = RubyLLM::Agents.configuration.per_page
         offset = (page - 1) * per_page
 
-        # Qualify column name to avoid ambiguity when joins are present
-        scope = scope.order("#{scope.model.table_name}.created_at DESC") if ordered
+        # Apply sorting - use custom sort_params if provided, otherwise default
+        table_name = scope.model.table_name
+        if sort_params.present?
+          scope = scope.order("#{table_name}.#{sort_params[:column]} #{sort_params[:direction].upcase}")
+        elsif ordered
+          scope = scope.order("#{table_name}.created_at DESC")
+        end
         total_count = scope.count
 
         {

data/app/controllers/concerns/ruby_llm/agents/sortable.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Controller concern for sorting
+    #
+    # Provides secure column sorting with whitelisted columns and direction validation.
+    # Prevents SQL injection by only allowing predefined sort columns.
+    #
+    # @example Using in a controller
+    #   include Sortable
+    #   @sort_params = parse_sort_params
+    #   result = paginate(scope, sort_params: @sort_params)
+    #
+    # @api private
+    module Sortable
+      extend ActiveSupport::Concern
+
+      # Whitelist of allowed sort columns mapped to their database column names
+      # Keys are the URL parameter values, values are the actual column names
+      SORTABLE_COLUMNS = {
+        "agent_type" => "agent_type",
+        "status" => "status",
+        "model_id" => "model_id",
+        "agent_version" => "agent_version",
+        "total_tokens" => "total_tokens",
+        "total_cost" => "total_cost",
+        "duration_ms" => "duration_ms",
+        "created_at" => "created_at"
+      }.freeze
+
+      SORT_DIRECTIONS = %w[asc desc].freeze
+      DEFAULT_SORT_COLUMN = "created_at"
+      DEFAULT_SORT_DIRECTION = "desc"
+
+      private
+
+      # Parses and validates sort parameters from the request
+      #
+      # Returns validated sort column and direction, falling back to defaults
+      # if invalid values are provided. This prevents SQL injection by only
+      # allowing whitelisted column names.
+      #
+      # @return [Hash] Contains :column and :direction keys
+      # @option return [String] :column The validated database column name
+      # @option return [String] :direction Either 'asc' or 'desc'
+      def parse_sort_params
+        column = params[:sort].to_s
+        direction = params[:direction].to_s.downcase
+
+        {
+          column: SORTABLE_COLUMNS[column] || DEFAULT_SORT_COLUMN,
+          direction: SORT_DIRECTIONS.include?(direction) ? direction : DEFAULT_SORT_DIRECTION
+        }
+      end
+    end
+  end
+end

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

@@ -16,21 +16,35 @@ module RubyLLM
       include Paginatable
       include Filterable
 
+      # Allowed sort columns for the agents list (in-memory sorting)
+      AGENT_SORTABLE_COLUMNS = %w[name agent_type model execution_count total_cost success_rate last_executed].freeze
+      DEFAULT_AGENT_SORT_COLUMN = "name"
+      DEFAULT_AGENT_SORT_DIRECTION = "asc"
+
       # Lists all registered agents with their details
       #
       # Uses AgentRegistry to discover agents from both file system
       # and execution history, ensuring deleted agents with history
       # are still visible. Separates agents and workflows for tabbed display.
+      # Deleted agents are shown in a separate tab.
       #
       # @return [void]
       def index
         all_items = AgentRegistry.all_with_details
 
-        # Separate agents and workflows
-        @agents = all_items.reject { |a| a[:is_workflow] }
-        @workflows = all_items.select { |a| a[:is_workflow] }
+        # Filter to only agents (not workflows)
+        all_agents = all_items.reject { |a| a[:is_workflow] }
+
+        # Separate active and deleted agents
+        @agents = all_agents.select { |a| a[:active] }
+        @deleted_agents = all_agents.reject { |a| a[:active] }
 
-        # Group agents by type for sub-tabs
+        # Parse and apply sorting to both lists
+        @sort_params = parse_agent_sort_params
+        @agents = sort_agents(@agents)
+        @deleted_agents = sort_agents(@deleted_agents)
+
+        # Group active agents by type for sub-tabs
         @agents_by_type = {
           agent: @agents.select { |a| a[:agent_type] == "agent" },
           embedder: @agents.select { |a| a[:agent_type] == "embedder" },
@@ -40,24 +54,16 @@ module RubyLLM
           image_generator: @agents.select { |a| a[:agent_type] == "image_generator" }
         }
 
-        # Group workflows by type for sub-tabs
-        @workflows_by_type = {
-          pipeline: @workflows.select { |w| w[:workflow_type] == "pipeline" },
-          parallel: @workflows.select { |w| w[:workflow_type] == "parallel" },
-          router: @workflows.select { |w| w[:workflow_type] == "router" }
-        }
-
-        # Counts for tab badges
         @agent_count = @agents.size
-        @workflow_count = @workflows.size
+        @deleted_count = @deleted_agents.size
       rescue StandardError => e
         Rails.logger.error("[RubyLLM::Agents] Error loading agents: #{e.message}")
         @agents = []
-        @workflows = []
+        @deleted_agents = []
         @agents_by_type = { agent: [], embedder: [], moderator: [], speaker: [], transcriber: [], image_generator: [] }
-        @workflows_by_type = { pipeline: [], parallel: [], router: [] }
         @agent_count = 0
-        @workflow_count = 0
+        @deleted_count = 0
+        @sort_params = { column: DEFAULT_AGENT_SORT_COLUMN, direction: DEFAULT_AGENT_SORT_DIRECTION }
         flash.now[:alert] = "Error loading agents list"
       end
 
@@ -404,6 +410,43 @@ module RubyLLM
         Rails.logger.debug("[RubyLLM::Agents] Could not load circuit breaker status: #{e.message}")
         @circuit_breaker_status = {}
       end
+
+      # Parses and validates sort parameters for agents list
+      #
+      # @return [Hash] Contains :column and :direction keys
+      def parse_agent_sort_params
+        column = params[:sort].to_s
+        direction = params[:direction].to_s.downcase
+
+        {
+          column: AGENT_SORTABLE_COLUMNS.include?(column) ? column : DEFAULT_AGENT_SORT_COLUMN,
+          direction: %w[asc desc].include?(direction) ? direction : DEFAULT_AGENT_SORT_DIRECTION
+        }
+      end
+
+      # Sorts agents array based on sort params
+      #
+      # @param agents [Array<Hash>] Array of agent hashes
+      # @return [Array<Hash>] Sorted array
+      def sort_agents(agents)
+        column = @sort_params[:column].to_sym
+        direction = @sort_params[:direction]
+
+        sorted = agents.sort_by do |agent|
+          value = agent[column]
+          # Handle nil values - put them at the end
+          case column
+          when :last_executed
+            value || Time.at(0)
+          when :execution_count, :total_cost, :success_rate
+            value || 0
+          else
+            value.to_s.downcase
+          end
+        end
+
+        direction == "desc" ? sorted.reverse : sorted
+      end
     end
   end
 end

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

@@ -27,32 +27,92 @@ module RubyLLM
         @agent_stats = build_agent_comparison(base_scope)
         @top_errors = build_top_errors(base_scope)
         @tenant_budget = load_tenant_budget(base_scope)
+        @model_stats = build_model_stats(base_scope)
       end
 
       # Returns chart data as JSON for live updates
       #
-      # @param range [String] Time range: "today", "7d", or "30d"
-      # @return [JSON] Chart data with series
+      # @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)
       def chart_data
         range = params[:range].presence || "today"
-        render json: tenant_scoped_executions.activity_chart_json(range: range)
+        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
+
+        render json: data
       end
 
       private
 
       # Converts range parameter to number of days
       #
-      # @param range [String] Range parameter (today, 7d, 30d)
+      # @param range [String] Range parameter (today, 7d, 30d, 60d, 90d, or custom YYYY-MM-DD_YYYY-MM-DD)
       # @return [Integer] Number of days
       def range_to_days(range)
         case range
         when "today" then 1
         when "7d" then 7
         when "30d" then 30
-        else 1
+        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
         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:
@@ -68,33 +128,35 @@ module RubyLLM
       # @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)
 
-        all_stats = agent_types.map do |agent_type|
-          agent_scope = scope.where(agent_type: agent_type)
-          count = agent_scope.count
-          total_cost = agent_scope.sum(:total_cost) || 0
-          successful = agent_scope.successful.count
+        # Get ALL agents from registry (file system + execution history)
+        all_agent_types = AgentRegistry.all
+
+        # Batch fetch stats for executed agents (4 queries total)
+        execution_stats = batch_fetch_agent_stats(scope)
 
-          # Detect agent type using AgentRegistry
+        all_stats = all_agent_types.map do |agent_type|
           agent_class = AgentRegistry.find(agent_type)
           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
 
+          # Get stats from batch or use zeros for never-executed agents
+          stats = execution_stats[agent_type] || {
+            count: 0, total_cost: 0, avg_cost: 0, avg_duration_ms: 0, success_rate: 0
+          }
+
           {
             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,
+            executions: stats[:count],
+            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
           }
-        end.sort_by { |a| -(a[:total_cost] || 0) }
+        end.sort_by { |a| [-(a[:executions] || 0), -(a[:total_cost] || 0)] }
 
         # Split stats by agent type for 7-tab display
         @agent_stats = all_stats.select { |a| a[:detected_type] == "agent" }
@@ -127,6 +189,42 @@ module RubyLLM
         end
       end
 
+      # Builds per-model statistics for model comparison and cost breakdown
+      #
+      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
+      # @return [Array<Hash>] Array of model stats sorted by total cost descending
+      def build_model_stats(base_scope = Execution)
+        scope = base_scope.last_n_days(@days).where.not(model_id: nil)
+
+        # Batch fetch stats grouped by model
+        counts = scope.group(:model_id).count
+        costs = scope.group(:model_id).sum(:total_cost)
+        tokens = scope.group(:model_id).sum(:total_tokens)
+        durations = scope.group(:model_id).average(:duration_ms)
+        success_counts = scope.successful.group(:model_id).count
+
+        total_cost = costs.values.sum
+
+        model_ids = counts.keys
+        model_ids.map do |model_id|
+          count = counts[model_id] || 0
+          model_cost = costs[model_id] || 0
+          model_tokens = tokens[model_id] || 0
+          successful = success_counts[model_id] || 0
+
+          {
+            model_id: model_id,
+            executions: count,
+            total_cost: model_cost,
+            total_tokens: model_tokens,
+            avg_duration_ms: durations[model_id]&.round || 0,
+            success_rate: count > 0 ? (successful.to_f / count * 100).round(1) : 0,
+            cost_per_1k_tokens: model_tokens > 0 ? (model_cost / model_tokens * 1000).round(4) : 0,
+            cost_percentage: total_cost > 0 ? (model_cost / total_cost * 100).round(1) : 0
+          }
+        end.sort_by { |m| -(m[:total_cost] || 0) }
+      end
+
       # Builds top errors list
       #
       # @param base_scope [ActiveRecord::Relation] Base scope to filter from
@@ -332,6 +430,32 @@ module RubyLLM
 
         alerts.take(3)
       end
+
+      # Batch fetches execution stats for all agents in a time period
+      #
+      # @param scope [ActiveRecord::Relation] Base scope with time filter
+      # @return [Hash<String, Hash>] Agent type => stats hash
+      def batch_fetch_agent_stats(scope)
+        counts = scope.group(:agent_type).count
+        costs = scope.group(:agent_type).sum(:total_cost)
+        success_counts = scope.successful.group(:agent_type).count
+        durations = scope.group(:agent_type).average(:duration_ms)
+
+        agent_types = (counts.keys + costs.keys).uniq
+        agent_types.each_with_object({}) do |agent_type, hash|
+          count = counts[agent_type] || 0
+          total_cost = costs[agent_type] || 0
+          successful = success_counts[agent_type] || 0
+
+          hash[agent_type] = {
+            count: count,
+            total_cost: total_cost,
+            avg_cost: count > 0 ? (total_cost / count).round(6) : 0,
+            avg_duration_ms: durations[agent_type]&.round || 0,
+            success_rate: count > 0 ? (successful.to_f / count * 100).round(1) : 0
+          }
+        end
+      end
     end
   end
 end

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

@@ -14,6 +14,7 @@ module RubyLLM
     class ExecutionsController < ApplicationController
       include Paginatable
       include Filterable
+      include Sortable
 
       CSV_COLUMNS = %w[id agent_type agent_version status model_id total_tokens total_cost
                        duration_ms created_at error_class error_message].freeze
@@ -206,12 +207,13 @@ module RubyLLM
 
       # Loads paginated executions and associated statistics
       #
-      # Sets @executions, @pagination, and @filter_stats instance variables
+      # Sets @executions, @pagination, @sort_params, and @filter_stats instance variables
       # for use in views.
       #
       # @return [void]
       def load_executions_with_stats
-        result = paginate(filtered_executions)
+        @sort_params = parse_sort_params
+        result = paginate(filtered_executions, sort_params: @sort_params)
         @executions = result[:records]
         @pagination = result[:pagination]
         load_filter_stats
@@ -238,9 +240,6 @@ module RubyLLM
       def filtered_executions
         scope = tenant_scoped_executions
 
-        # Apply search filter
-        scope = scope.search(params[:q]) if params[:q].present?
-
         # Apply agent type filter
         agent_types = parse_array_param(:agent_types)
         if agent_types.any?
@@ -288,6 +287,9 @@ module RubyLLM
         # 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
         scope = scope.where(parent_execution_id: nil)
 
@@ -297,7 +299,7 @@ module RubyLLM
         scope
       end
 
-      # Applies execution type tab filter (all, agents, workflows)
+      # Applies execution type filter (all, agents, workflows, or specific workflow type)
       #
       # @param scope [ActiveRecord::Relation] The current scope
       # @return [ActiveRecord::Relation] Filtered scope
@@ -310,16 +312,11 @@ module RubyLLM
           # 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
-          workflow_scope = scope.where.not(workflow_type: [nil, ""])
-
-          # Apply workflow type sub-filter if specified
-          workflow_type_tab = params[:workflow_type_tab]
-          if workflow_type_tab.present? && %w[pipeline parallel router].include?(workflow_type_tab)
-            workflow_scope = workflow_scope.where(workflow_type: workflow_type_tab)
-          end
-
-          workflow_scope
+          # 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