ruby_llm-agents 3.15.1 → 3.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50ffc9d68f60773bb6d86c42addae6911999d703eadd295bd30b5e4fcc5858f6
-  data.tar.gz: b6c40aa4a3f1ef6ac52e4d2beeb27871038a48d8c80ba71b37dcbd43f21394de
+  metadata.gz: 67962a08cb48a28feb5b1dc27557ddb959fbdd034314e8734410f6626cdd66fb
+  data.tar.gz: cc87df7123f4cd180eda63945ae703b3e9dd927e5caef5c2164a0971e9b4fc56
 SHA512:
-  metadata.gz: e3f02b1ff28adcb9b102acdcbed8e31470130c1763470af992a501750681ae0c9ebe86b3a2bf5152dcd40216b7f3fe2298c5d1959e54957dba947084d14317a9
-  data.tar.gz: 8f8c8a9942c6123a92d0e9f0a2f7424fd2d655ca27689cf58faf7358ce2964fca9f4d155527990392f22b89d2127b7c54c90bb43e11c41f695c87baaedb12550
+  metadata.gz: 67d4507bf18669118aa35180124d0b4bbeabd512260598f042f608551acb9ba86eed3342e7e93c0a4d252d8ccc212e844e405d5d20b805882f7c1616637adb9d
+  data.tar.gz: 79699601f5b3763ecd13f4eb133115fd83823fba5fbed5b492109991ab2ca4f0a49139b540c72dffe53f8bcff4d2c3d83159c0fc93ace0da83c6fa95cc10f657

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

@@ -7,7 +7,8 @@ module RubyLLM
     # Provides simple offset-based pagination with consistent return format.
     #
     # @example Using in a controller
-    #   result = paginate(Execution.all)
+    #   stats = scope.totals
+    #   result = paginate(scope, total_count: stats[:total_count])
     #   @executions = result[:records]
     #   @pagination = result[:pagination]
     #
@@ -19,17 +20,25 @@ module RubyLLM
 
       # Paginates a scope with optional ordering
       #
+      # Counting every row a filter matches is the expensive half of
+      # pagination on a large table, so the count is the caller's to supply
+      # (usually from an aggregate it needed anyway). Without one the page is
+      # still served: one extra row is fetched to learn whether a next page
+      # exists, and the view falls back to prev/next links.
+      #
       # @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
+      # @param total_count [Integer, nil] Total rows in the scope, when known
       # @return [Hash] Contains :records and :pagination keys
-      # @option return [ActiveRecord::Relation] :records Paginated records
+      # @option return [Array, ActiveRecord::Relation] :records The loaded page
       # @option return [Hash] :pagination Pagination metadata
       #   - :current_page [Integer] Current page number
       #   - :per_page [Integer] Records per page
-      #   - :total_count [Integer] Total record count
-      #   - :total_pages [Integer] Total page count
-      def paginate(scope, ordered: true, sort_params: nil)
+      #   - :total_count [Integer, nil] Total record count, nil when unknown
+      #   - :total_pages [Integer, nil] Total page count, nil when unknown
+      #   - :next_page [Boolean] Whether a later page exists
+      def paginate(scope, ordered: true, sort_params: nil, total_count: nil)
         page = [(params[:page] || 1).to_i, 1].max
         per_page = RubyLLM::Agents.configuration.per_page
         offset = (page - 1) * per_page
@@ -41,15 +50,27 @@ module RubyLLM
         elsif ordered
           scope = scope.order("#{table_name}.created_at DESC")
         end
-        total_count = scope.count
+
+        # Loaded eagerly: the views call `records.empty?` before iterating,
+        # which on an unloaded relation costs a second SELECT.
+        if total_count
+          records = scope.offset(offset).limit(per_page).load
+          total_pages = (total_count.to_f / per_page).ceil
+          next_page = page < total_pages
+        else
+          records = scope.offset(offset).limit(per_page + 1).to_a
+          next_page = records.size > per_page
+          records = records.first(per_page)
+        end
 
         {
-          records: scope.offset(offset).limit(per_page),
+          records: records,
           pagination: {
             current_page: page,
             per_page: per_page,
             total_count: total_count,
-            total_pages: (total_count.to_f / per_page).ceil
+            total_pages: total_pages,
+            next_page: next_page
           }
         }
       end

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

@@ -21,6 +21,13 @@ module RubyLLM
       DEFAULT_AGENT_SORT_COLUMN = "name"
       DEFAULT_AGENT_SORT_DIRECTION = "asc"
 
+      # Days of history behind the agent page's headline stats and trend chart
+      STATS_WINDOW_DAYS = 30
+
+      # Seconds the executions table may spend counting before it renders
+      # with prev/next links only
+      TOTALS_TIMEOUT = 1
+
       # Lists all registered agents with their details
       #
       # Uses AgentRegistry to discover agents from both file system
@@ -56,6 +63,10 @@ module RubyLLM
 
         @agent_count = @agents.size
         @deleted_count = @deleted_agents.size
+        @stats_window_days = AgentRegistry::STATS_WINDOW.in_days.to_i
+        @stats_available = all_agents.empty? || all_agents.any? { |a| a[:execution_count] }
+      rescue ::ActiveRecord::QueryCanceled
+        raise
       rescue => e
         Rails.logger.error("[RubyLLM::Agents] Error loading agents: #{e.message}")
         @agents = []
@@ -64,6 +75,8 @@ module RubyLLM
         @agent_count = 0
         @deleted_count = 0
         @sort_params = {column: DEFAULT_AGENT_SORT_COLUMN, direction: DEFAULT_AGENT_SORT_DIRECTION}
+        @stats_window_days = AgentRegistry::STATS_WINDOW.in_days.to_i
+        @stats_available = true
         flash.now[:alert] = "Error loading agents list"
       end
 
@@ -80,7 +93,6 @@ module RubyLLM
         @agent_active = @agent_class.present?
 
         load_agent_stats
-        load_filter_options
         load_filtered_executions
         load_chart_data
 
@@ -89,6 +101,8 @@ module RubyLLM
           # Load circuit breaker status for agents that support reliability
           load_circuit_breaker_status if @agent_type_kind.in?(%w[agent router])
         end
+      rescue ::ActiveRecord::QueryCanceled
+        raise
       rescue => e
         Rails.logger.error("[RubyLLM::Agents] Error loading agent #{@agent_type}: #{e.message}")
         redirect_to ruby_llm_agents.agents_path, alert: "Error loading agent details"
@@ -152,55 +166,48 @@ module RubyLLM
 
       private
 
-      # Loads all-time and today's statistics for the agent
+      # Loads the agent's headline statistics
+      #
+      # @stats covers the last STATS_WINDOW_DAYS rather than all time: an
+      # agent's whole history can be millions of rows, and each figure here
+      # used to be its own scan of it. Both hashes come from one query each.
       #
       # @return [void]
       def load_agent_stats
-        base = tenant_scoped_executions
-        @stats = base.stats_for(@agent_type, period: :all_time)
-        @stats_today = base.stats_for(@agent_type, period: :today)
-
-        # Additional stats for new schema fields
-        agent_scope = base.by_agent(@agent_type)
-        @cache_hit_rate = agent_scope.cache_hit_rate
-        @streaming_rate = agent_scope.streaming_rate
-        @avg_ttft = agent_scope.avg_time_to_first_token
-      end
+        agent_scope = tenant_scoped_executions.by_agent(@agent_type)
 
-      # Loads available filter options from execution history
-      #
-      # Uses a single optimized query to fetch all filter values
-      # (versions, models, temperatures) avoiding N+1 queries.
-      #
-      # @return [void]
-      def load_filter_options
-        # Single query to get all filter options (fixes N+1)
-        base = tenant_scoped_executions.by_agent(@agent_type)
-        filter_data = base
-          .where.not(model_id: nil)
-          .or(base.where.not(temperature: nil))
-          .pluck(:model_id, :temperature)
-
-        @models = filter_data.map(&:first).compact.uniq.sort
-        @temperatures = filter_data.map(&:last).compact.uniq.sort
+        @stats_window_days = STATS_WINDOW_DAYS
+        @stats = cached_stats(:agent_summary, @agent_type, expires_in: 5.minutes) do
+          agent_scope.last_n_days(STATS_WINDOW_DAYS).usage_summary
+        end
+        @stats_today = cached_stats(:agent_today, @agent_type, expires_in: 30.seconds) do
+          agent_scope.today.usage_summary
+        end
+        @cache_hit_rate = @stats[:cache_hit_rate]
+        @streaming_rate = @stats[:streaming_rate]
       end
 
-      # Loads paginated and filtered executions with statistics
+      # Loads paginated and filtered executions
       #
-      # Sets @executions, @pagination, and @filter_stats for the view.
+      # Sets @executions, @pagination, and @filter_stats for the view. The
+      # count behind the page numbers is best-effort, as on the executions
+      # index: unfiltered, it is a count of the agent's entire history.
       #
       # @return [void]
       def load_filtered_executions
         base_scope = build_filtered_scope
-        result = paginate(base_scope)
+
+        filters = request.query_parameters.except("page")
+        @filter_stats = cached_stats(:agent_totals, @agent_type, filters.to_query) do
+          Execution.best_effort(timeout: TOTALS_TIMEOUT) { base_scope.totals }
+        end
+
+        # error_detail: the table renders error_message per row, and the full
+        # detail row carries every prompt and response payload.
+        result = paginate(base_scope.preload(:error_detail),
+          total_count: @filter_stats&.fetch(:total_count))
         @executions = result[:records]
         @pagination = result[:pagination]
-
-        @filter_stats = {
-          total_count: result[:pagination][:total_count],
-          total_cost: base_scope.sum(:total_cost),
-          total_tokens: base_scope.sum(:total_tokens)
-        }
       end
 
       # Builds a filtered scope for the current agent's executions
@@ -229,16 +236,13 @@ module RubyLLM
         apply_time_filter(scope, days)
       end
 
-      # Loads chart data for agent performance visualization
-      #
-      # Fetches 30-day trend analysis and status/finish_reason distribution for charts.
+      # Loads the 30-day trend for the agent's chart
       #
       # @return [void]
       def load_chart_data
-        base = tenant_scoped_executions
-        @trend_data = base.trend_analysis(agent_type: @agent_type, days: 30)
-        @status_distribution = base.by_agent(@agent_type).group(:status).count
-        @finish_reason_distribution = base.by_agent(@agent_type).finish_reason_distribution
+        @trend_data = cached_stats(:agent_trend, @agent_type, expires_in: 5.minutes) do
+          tenant_scoped_executions.trend_analysis(agent_type: @agent_type, days: STATS_WINDOW_DAYS)
+        end
       end
 
       # Loads the current agent class configuration

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

@@ -13,6 +13,10 @@ module RubyLLM
       VALID_RANGES = %w[7d 30d 90d custom].freeze
       DEFAULT_RANGE = "30d"
 
+      # Every section covers the same filtered range, so they are all derived
+      # from one Breakdown of it: the page scans the range once, plus one
+      # aggregate each for the prior period and the month to date. Results
+      # are cached, since these ranges are wide and move slowly.
       def index
         @selected_range = sanitize_range(params[:range])
         @days = range_to_days(@selected_range)
@@ -21,12 +25,13 @@ module RubyLLM
         load_filter_options
         base = apply_filters(time_scoped(tenant_scoped_executions))
         prior = apply_filters(prior_period_scope(tenant_scoped_executions))
+        breakdown = Execution::Breakdown.new(cached_analytics(:breakdown) { base.breakdown.rows })
 
-        load_summary(base, prior)
+        load_summary(breakdown, cached_analytics(:prior) { aggregate(prior) })
         load_projection(base)
-        load_savings_opportunity(base)
-        load_efficiency(base)
-        load_error_cost(base)
+        load_savings_opportunity(breakdown)
+        @efficiency = breakdown.model_stats
+        load_error_cost(breakdown)
       end
 
       # Returns chart JSON: current period + prior period overlay
@@ -39,7 +44,7 @@ module RubyLLM
         current_scope = apply_filters(time_scoped(tenant_scoped_executions))
         prior_scope = apply_filters(prior_period_scope(tenant_scoped_executions))
 
-        render json: build_overlay_chart_json(current_scope, prior_scope)
+        render json: cached_analytics(:chart) { build_overlay_chart_json(current_scope, prior_scope) }
       end
 
       private
@@ -106,9 +111,8 @@ module RubyLLM
       # ── Filters ──────────────────────────
 
       def load_filter_options
-        base = tenant_scoped_executions
-        @available_agents = base.where.not(agent_type: nil).distinct.pluck(:agent_type).sort
-        @available_models = base.where.not(model_id: nil).distinct.pluck(:model_id).sort
+        @available_agents = available_agent_types
+        @available_models = available_model_ids
         @available_tenants = if tenant_filter_enabled? && Tenant.table_exists?
           Tenant.pluck(:tenant_id, :name).map { |tid, name| [tid, name.presence || tid] }.sort_by(&:last)
         else
@@ -137,18 +141,23 @@ module RubyLLM
 
       # ── Data loaders ──────────────────────────
 
-      def load_summary(base, prior)
-        current_agg = aggregate(base)
-        prior_agg = aggregate(prior)
+      # Caches one of the page's figures under the selected range and filters
+      def cached_analytics(name, &block)
+        cached_stats(:analytics, name, @selected_range, @custom_from, @custom_to,
+          @filter_agent, @filter_model, @filter_tenant, expires_in: 5.minutes, &block)
+      end
+
+      def load_summary(breakdown, prior_agg)
+        totals = breakdown.totals
 
         @summary = {
-          total_cost: current_agg[:cost],
-          total_runs: current_agg[:count],
-          total_tokens: current_agg[:tokens],
-          avg_cost: (current_agg[:count] > 0) ? (current_agg[:cost].to_f / current_agg[:count]) : 0,
-          avg_tokens: (current_agg[:count] > 0) ? (current_agg[:tokens].to_f / current_agg[:count]).round : 0,
-          cost_change: pct_change(prior_agg[:cost], current_agg[:cost]),
-          runs_change: pct_change(prior_agg[:count], current_agg[:count]),
+          total_cost: totals[:cost],
+          total_runs: totals[:total],
+          total_tokens: totals[:tokens],
+          avg_cost: (totals[:total] > 0) ? (totals[:cost] / totals[:total]) : 0,
+          avg_tokens: (totals[:total] > 0) ? (totals[:tokens].to_f / totals[:total]).round : 0,
+          cost_change: pct_change(prior_agg[:cost], totals[:cost]),
+          runs_change: pct_change(prior_agg[:count], totals[:total]),
           prior_cost: prior_agg[:cost],
           prior_runs: prior_agg[:count]
         }
@@ -160,8 +169,10 @@ module RubyLLM
         # Calculate daily burn rate and project to end of month
         daily_rate = @summary[:total_cost].to_f / @days
         days_left = (Date.current.end_of_month - Date.current).to_i
-        month_so_far = base.where("created_at >= ?", Date.current.beginning_of_month.beginning_of_day)
-          .sum(:total_cost).to_f
+        month_so_far = cached_analytics(:month_so_far) do
+          base.where("created_at >= ?", Date.current.beginning_of_month.beginning_of_day)
+            .sum(:total_cost).to_f
+        end
 
         @projection = {
           daily_rate: daily_rate,
@@ -171,31 +182,9 @@ module RubyLLM
         }
       end
 
-      def load_savings_opportunity(base)
+      def load_savings_opportunity(breakdown)
         # Find the most expensive model and suggest switching to the cheapest
-        models = base.where.not(model_id: nil)
-          .select(
-            :model_id,
-            Arel.sql("COUNT(*) AS exec_count"),
-            Arel.sql("COALESCE(SUM(total_cost), 0) AS sum_cost"),
-            Arel.sql("COALESCE(SUM(total_tokens), 0) AS sum_tokens")
-          )
-          .group(:model_id)
-          .order(Arel.sql("sum_cost DESC"))
-
-        model_data = models.map do |row|
-          count = row["exec_count"].to_i
-          cost = row["sum_cost"].to_f
-          tokens = row["sum_tokens"].to_i
-          {
-            model_id: row.model_id,
-            runs: count,
-            cost: cost,
-            tokens: tokens,
-            cost_per_run: (count > 0) ? (cost / count) : 0,
-            cost_per_1k_tokens: (tokens > 0) ? (cost / tokens * 1000) : 0
-          }
-        end
+        model_data = breakdown.configured_model_usage
 
         @savings = nil
         return if model_data.size < 2
@@ -219,35 +208,12 @@ module RubyLLM
         }
       end
 
-      def load_efficiency(base)
-        @efficiency = Execution.model_stats(scope: base)
-      end
+      def load_error_cost(breakdown)
+        error_cost = breakdown.error_cost(limit: 10)
 
-      def load_error_cost(base)
-        error_scope = base.where(status: "error")
-        @error_total_cost = error_scope.sum(:total_cost) || 0
-        @error_total_count = error_scope.count
-
-        @error_breakdown = error_scope
-          .select(
-            :error_class,
-            :agent_type,
-            Arel.sql("COUNT(*) AS err_count"),
-            Arel.sql("COALESCE(SUM(total_cost), 0) AS err_cost"),
-            Arel.sql("MAX(created_at) AS last_seen")
-          )
-          .group(:error_class, :agent_type)
-          .order(Arel.sql("err_cost DESC"))
-          .limit(10)
-          .map do |row|
-            {
-              error_class: row.error_class || "Unknown",
-              agent_type: row.agent_type,
-              count: row["err_count"].to_i,
-              cost: row["err_cost"].to_f,
-              last_seen: row["last_seen"]
-            }
-          end
+        @error_total_cost = error_cost[:total_cost]
+        @error_total_count = error_cost[:total_count]
+        @error_breakdown = error_cost[:breakdown]
       end
 
       # ── Helpers ──────────────────────────

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

@@ -13,8 +13,12 @@ module RubyLLM
     class DashboardController < ApplicationController
       # Renders the main dashboard view
       #
-      # Loads now strip data, critical alerts, hourly activity,
-      # recent executions, agent comparison, and top errors.
+      # Loads now strip data, critical alerts, recent executions, agent and
+      # model comparison, top errors and cache savings.
+      #
+      # Every section that covers the selected range is derived from a single
+      # Breakdown of it, so the page scans that window once (twice, counting
+      # the previous-period comparison) however many sections it shows.
       #
       # @return [void]
       def index
@@ -22,14 +26,15 @@ module RubyLLM
         @days = range_to_days(@selected_range)
         parse_custom_dates if @selected_range == "custom"
         base_scope = tenant_scoped_executions
-        @now_strip = build_now_strip(base_scope)
+        breakdown = load_breakdown(base_scope)
+        @now_strip = build_now_strip(base_scope, breakdown)
         @critical_alerts = load_critical_alerts(base_scope)
-        @recent_executions = base_scope.includes(:detail).recent(10)
-        @agent_stats = build_agent_comparison(base_scope)
-        @top_errors = build_top_errors(base_scope)
+        @recent_executions = base_scope.preload(:error_detail).recent(10)
+        @agent_stats = build_agent_comparison(breakdown)
+        @top_errors = breakdown.top_errors
         @tenant_budget = load_tenant_budget(base_scope)
-        @model_stats = build_model_stats(base_scope)
-        @cache_savings = build_cache_savings(base_scope)
+        @model_stats = breakdown.model_stats
+        @cache_savings = breakdown.cache_savings
         @top_tenants = build_top_tenants
       end
 
@@ -40,19 +45,19 @@ module RubyLLM
       def chart_data
         range = sanitize_range(params[:range])
         scope = tenant_scoped_executions
+        from = parse_date(params[:from])
+        to = parse_date(params[:to])
+        custom = range == "custom" && from && to
+        from, to = [from, to].sort if custom
 
-        data = if range == "custom"
-          from = parse_date(params[:from])
-          to = parse_date(params[:to])
-          if from && to
-            from, to = [from, to].sort
-            to = [to, Date.current].min
-            scope.activity_chart_json_for_dates(from: from, to: to)
-          else
+        data = cached_stats(:dashboard_chart, range, (from if custom), (to if custom), expires_in: stats_ttl(range)) do
+          if custom
+            scope.activity_chart_json_for_dates(from: from, to: [to, Date.current].min)
+          elsif range == "custom"
             scope.activity_chart_json(range: "today")
+          else
+            scope.activity_chart_json(range: range)
           end
-        else
-          scope.activity_chart_json(range: range)
         end
 
         render json: data
@@ -131,16 +136,51 @@ module RubyLLM
         end
       end
 
-      # Routes to the correct now_strip_data method based on range
+      # How long the figures for a range may be served from cache
+      #
+      # "today" is the live view, so it stays close to real time. The wider
+      # ranges move slowly and are the expensive ones to recompute.
+      #
+      # @param range [String] Sanitized range
+      # @return [ActiveSupport::Duration]
+      def stats_ttl(range)
+        (range == "today") ? 30.seconds : 5.minutes
+      end
+
+      # Scans the selected range once, grouped for every section of the page
+      #
+      # @param base_scope [ActiveRecord::Relation] Base scope
+      # @return [Execution::Breakdown]
+      def load_breakdown(base_scope)
+        rows = cached_stats(:dashboard_breakdown, @selected_range, @custom_from, @custom_to,
+          expires_in: stats_ttl(@selected_range)) { time_scoped(base_scope).breakdown.rows }
+
+        Execution::Breakdown.new(rows)
+      end
+
+      # Builds the now strip, reusing the breakdown for the current period
+      #
+      # The strip's current period is the breakdown's window for every range
+      # except "today" (the strip counts from midnight, the other sections
+      # cover the last 24 hours), so only "today" scans it separately. The
+      # running count is always read live.
       #
       # @param base_scope [ActiveRecord::Relation] Base scope
+      # @param breakdown [Execution::Breakdown] Breakdown of the selected range
       # @return [Hash] Now strip metrics
-      def build_now_strip(base_scope)
-        if @selected_range == "custom" && @custom_from && @custom_to
-          base_scope.now_strip_data_for_dates(from: @custom_from, to: @custom_to)
-        else
-          base_scope.now_strip_data(range: @selected_range)
+      def build_now_strip(base_scope, breakdown)
+        strip = cached_stats(:dashboard_now_strip, @selected_range, @custom_from, @custom_to,
+          expires_in: stats_ttl(@selected_range)) do
+          if @selected_range == "custom" && @custom_from && @custom_to
+            base_scope.now_strip_data_for_dates(from: @custom_from, to: @custom_to, current: breakdown.totals)
+          elsif @selected_range == "today"
+            base_scope.now_strip_data(range: "today")
+          else
+            base_scope.now_strip_data(range: @selected_range, current: breakdown.totals)
+          end
         end
+
+        strip.merge(running: base_scope.running.count)
       end
 
       # Builds per-agent comparison statistics for all agent types
@@ -152,22 +192,18 @@ module RubyLLM
       # - @speaker_stats: Speakers
       # - @image_generator_stats: Image generators
       #
-      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
+      # @param breakdown [Execution::Breakdown] Breakdown of the selected range
       # @return [Array<Hash>] Array of base agent stats (for backward compatibility)
-      def build_agent_comparison(base_scope = Execution)
-        scope = time_scoped(base_scope)
-
+      def build_agent_comparison(breakdown)
         # 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)
+        execution_stats = breakdown.agent_stats
 
         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 stats from batch or use zeros for never-executed agents
+          # Zeros for agents with no executions in the range
           stats = execution_stats[agent_type] || {
             count: 0, total_cost: 0, avg_cost: 0, avg_duration_ms: 0, success_rate: 0
           }
@@ -194,16 +230,6 @@ module RubyLLM
         @agent_stats
       end
 
-      # Delegates to Execution.model_stats with time scoping
-      def build_model_stats(base_scope = Execution)
-        Execution.model_stats(scope: time_scoped(base_scope))
-      end
-
-      # Delegates to Execution.top_errors with time scoping
-      def build_top_errors(base_scope = Execution)
-        Execution.top_errors(scope: time_scoped(base_scope))
-      end
-
       # Loads budget status for display on dashboard
       #
       # @return [Hash] Budget status with global daily and monthly info
@@ -217,10 +243,7 @@ module RubyLLM
       def load_open_breakers
         open_breakers = []
 
-        # Get all agents from execution history
-        agent_types = tenant_scoped_executions.distinct.pluck(:agent_type)
-
-        agent_types.each do |agent_type|
+        available_agent_types.each do |agent_type|
           # Get the agent class if available
           agent_class = AgentRegistry.find(agent_type)
           next unless agent_class
@@ -349,20 +372,10 @@ module RubyLLM
         alerts.take(3)
       end
 
-      # Delegates to Execution.cache_savings with time scoping
-      def build_cache_savings(base_scope)
-        Execution.cache_savings(scope: time_scoped(base_scope))
-      end
-
       # Delegates to Tenant.top_by_spend
       def build_top_tenants
         Tenant.top_by_spend(limit: 5)
       end
-
-      # Delegates to Execution.batch_agent_stats with pre-filtered scope
-      def batch_fetch_agent_stats(scope)
-        Execution.batch_agent_stats(scope: scope)
-      end
     end
   end
 end