ruby_llm-agents 3.11.0 → 3.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2db1aa75b826b63dae9aec7ee8bee4e3597ce9dab4509e49dcd5cc6bdd8b3aa8
-  data.tar.gz: aa5b53d9558b0724ba89a39575b2ac2c3ba2eda550c87d3388f3f66cbda6d0e3
+  metadata.gz: 5e29829dcedb6a67dd1d9e55c7a45ead560e5da2fc0f75ffd04c97026e8d5b90
+  data.tar.gz: 9c2981a6eed9459f2c7d56c47f6ff5ddcdd282bc90729ace04b8eca4f83e9e55
 SHA512:
-  metadata.gz: c5537dd90aaceadb9b0948687d3a1ed6635e5c93d8b82a2eae23f805dcb3fc14c32c37aa3fa7bf56a581b48ea72e0d8b0c730f750fc866a6fc4461d784a3ac49
-  data.tar.gz: ebbaa8c6c7cf7d27163fbd33c1436cd3332ebbc7069eef6a6b24b50d12e75fd7b962dfaba21faf94d52e8a7ba67a37073c33dc82c91058beb32d486ef3565fc8
+  metadata.gz: 86ed72b1e799b64259b83588ac9c9111d04539eb7225e65d517332d22ed671436214255ec0127fdcff4ef65fe283683219e88b67a956c6270a7b6a0140937a27
+  data.tar.gz: b532f5a4a47814ed19a9929b06e506b56af651d8d1be65348c68b61aa78dc48f771c89c8d667dac06860d88283fee3a890b8d39afc4d11f5e6905ceca396c136

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

@@ -94,6 +94,62 @@ module RubyLLM
         redirect_to ruby_llm_agents.agents_path, alert: "Error loading agent details"
       end
 
+      # Saves dashboard overrides for an agent's overridable settings
+      #
+      # Only persists values for fields the agent has declared as
+      # `overridable: true` in its DSL. Ignores all other fields.
+      #
+      # @return [void]
+      def update
+        @agent_type = CGI.unescape(params[:id])
+        @agent_class = AgentRegistry.find(@agent_type)
+
+        unless @agent_class
+          redirect_to ruby_llm_agents.agents_path, alert: "Agent not found"
+          return
+        end
+
+        allowed = @agent_class.overridable_fields.map(&:to_s)
+        if allowed.empty?
+          redirect_to agent_path(@agent_type), alert: "This agent has no overridable fields"
+          return
+        end
+
+        # Build settings hash from permitted params, only for overridable fields
+        settings = {}
+        allowed.each do |field|
+          next unless params.dig(:override, field).present?
+
+          raw = params[:override][field]
+          settings[field] = coerce_override_value(field, raw)
+        end
+
+        override = AgentOverride.find_or_initialize_by(agent_type: @agent_type)
+
+        if settings.empty?
+          # No overrides left — delete the record
+          override.destroy if override.persisted?
+          redirect_to agent_path(@agent_type), notice: "Overrides cleared"
+        else
+          override.settings = settings
+          if override.save
+            redirect_to agent_path(@agent_type), notice: "Overrides saved"
+          else
+            redirect_to agent_path(@agent_type), alert: "Failed to save overrides"
+          end
+        end
+      end
+
+      # Removes all dashboard overrides for an agent
+      #
+      # @return [void]
+      def reset_overrides
+        @agent_type = CGI.unescape(params[:id])
+        override = AgentOverride.find_by(agent_type: @agent_type)
+        override&.destroy
+        redirect_to agent_path(@agent_type), notice: "Overrides cleared"
+      end
+
       private
 
       # Loads all-time and today's statistics for the agent
@@ -294,6 +350,24 @@ module RubyLLM
 
         (direction == "desc") ? sorted.reverse : sorted
       end
+
+      # Coerces an override value from the form string to the appropriate Ruby type
+      #
+      # @param field [String] The field name
+      # @param raw [String] The raw string value from the form
+      # @return [Object] The coerced value
+      def coerce_override_value(field, raw)
+        case field
+        when "temperature"
+          raw.to_f
+        when "timeout"
+          raw.to_i
+        when "streaming"
+          ActiveModel::Type::Boolean.new.cast(raw)
+        else
+          raw.to_s
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Controller for cost intelligence and analytics
+    #
+    # Provides interactive, filterable cost analysis across agents, models,
+    # and tenants. The filter bar (agent/model/tenant) applies to all sections,
+    # making this an exploration tool rather than a static report.
+    #
+    # @api private
+    class AnalyticsController < ApplicationController
+      VALID_RANGES = %w[7d 30d 90d custom].freeze
+      DEFAULT_RANGE = "30d"
+
+      def index
+        @selected_range = sanitize_range(params[:range])
+        @days = range_to_days(@selected_range)
+        parse_custom_dates if @selected_range == "custom"
+
+        load_filter_options
+        base = apply_filters(time_scoped(tenant_scoped_executions))
+        prior = apply_filters(prior_period_scope(tenant_scoped_executions))
+
+        load_summary(base, prior)
+        load_projection(base)
+        load_savings_opportunity(base)
+        load_efficiency(base)
+        load_error_cost(base)
+      end
+
+      # Returns chart JSON: current period + prior period overlay
+      def chart_data
+        @selected_range = sanitize_range(params[:range])
+        @days = range_to_days(@selected_range)
+        parse_custom_dates if @selected_range == "custom"
+
+        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)
+      end
+
+      private
+
+      # ── Time helpers ──────────────────────────
+
+      def sanitize_range(range)
+        VALID_RANGES.include?(range) ? range : DEFAULT_RANGE
+      end
+
+      def range_to_days(range)
+        case range
+        when "7d" then 7
+        when "30d" then 30
+        when "90d" then 90
+        else 30
+        end
+      end
+
+      def parse_date(value)
+        return nil if value.blank?
+        date = Date.parse(value)
+        return nil if date > Date.current
+        return nil if date < 1.year.ago.to_date
+        date
+      rescue ArgumentError
+        nil
+      end
+
+      def parse_custom_dates
+        from = parse_date(params[:from])
+        to = parse_date(params[:to])
+
+        if from && to
+          from, to = [from, to].sort
+          @custom_from = from
+          @custom_to = [to, Date.current].min
+          @days = (@custom_to - @custom_from).to_i + 1
+        else
+          @selected_range = DEFAULT_RANGE
+          @days = 30
+        end
+      end
+
+      def time_scoped(scope)
+        if @selected_range == "custom" && @custom_from && @custom_to
+          scope.where(created_at: @custom_from.beginning_of_day..@custom_to.end_of_day)
+        else
+          scope.last_n_days(@days)
+        end
+      end
+
+      def prior_period_scope(scope)
+        if @selected_range == "custom" && @custom_from && @custom_to
+          duration = @custom_to - @custom_from + 1
+          prior_end = @custom_from - 1.day
+          prior_start = prior_end - duration.days + 1.day
+          scope.where(created_at: prior_start.beginning_of_day..prior_end.end_of_day)
+        else
+          scope.where(created_at: (@days * 2).days.ago...@days.days.ago)
+        end
+      end
+
+      # ── 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_tenants = if tenant_filter_enabled? && Tenant.table_exists?
+          Tenant.pluck(:tenant_id, :name).map { |tid, name| [tid, name.presence || tid] }.sort_by(&:last)
+        else
+          []
+        end
+
+        @filter_agent = params[:agent].presence
+        @filter_model = params[:model].presence
+        @filter_tenant = params[:filter_tenant].presence
+        @any_filter = @filter_agent || @filter_model || @filter_tenant
+      end
+
+      def apply_filters(scope)
+        scope = scope.where(agent_type: @filter_agent) if @filter_agent.present?
+        scope = scope.where(model_id: @filter_model) if @filter_model.present?
+        scope = scope.where(tenant_id: @filter_tenant) if @filter_tenant.present?
+        scope
+      end
+
+      # ── Data loaders ──────────────────────────
+
+      def load_summary(base, prior)
+        current_agg = aggregate(base)
+        prior_agg = aggregate(prior)
+
+        @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]),
+          prior_cost: prior_agg[:cost],
+          prior_runs: prior_agg[:count]
+        }
+      end
+
+      def load_projection(base)
+        return @projection = nil if @days.nil? || @summary[:total_cost].zero?
+
+        # 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
+
+        @projection = {
+          daily_rate: daily_rate,
+          month_so_far: month_so_far,
+          projected_month: month_so_far + (daily_rate * days_left),
+          days_left: days_left
+        }
+      end
+
+      def load_savings_opportunity(base)
+        # 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
+
+        @savings = nil
+        return if model_data.size < 2
+
+        expensive = model_data.first
+        cheapest = model_data.min_by { |m| m[:cost_per_run] }
+
+        return if expensive[:model_id] == cheapest[:model_id]
+        return if expensive[:cost_per_run] <= cheapest[:cost_per_run]
+
+        potential_savings = (expensive[:cost_per_run] - cheapest[:cost_per_run]) * expensive[:runs]
+        return if potential_savings < 0.001
+
+        @savings = {
+          expensive_model: expensive[:model_id],
+          expensive_runs: expensive[:runs],
+          expensive_cost_per_run: expensive[:cost_per_run],
+          cheap_model: cheapest[:model_id],
+          cheap_cost_per_run: cheapest[:cost_per_run],
+          potential_savings: potential_savings
+        }
+      end
+
+      def load_efficiency(base)
+        @efficiency = Execution.model_stats(scope: base)
+      end
+
+      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
+      end
+
+      # ── Helpers ──────────────────────────
+
+      def aggregate(scope)
+        result = scope.pick(
+          Arel.sql("COUNT(*)"),
+          Arel.sql("COALESCE(SUM(total_cost), 0)"),
+          Arel.sql("COALESCE(SUM(total_tokens), 0)")
+        )
+        {count: result[0].to_i, cost: result[1].to_f, tokens: result[2].to_i}
+      end
+
+      def pct_change(old_val, new_val)
+        return 0.0 if old_val.nil? || old_val.to_f.zero?
+        ((new_val.to_f - old_val.to_f) / old_val.to_f * 100).round(1)
+      end
+
+      def date_bucket_sql
+        if ::ActiveRecord::Base.connection.adapter_name.downcase.include?("sqlite")
+          "strftime('%Y-%m-%d', created_at)"
+        else
+          "date_trunc('day', created_at)::date"
+        end
+      end
+
+      # Builds current + prior period overlay chart
+      def build_overlay_chart_json(current_scope, prior_scope)
+        current_daily = daily_cost(current_scope)
+        prior_daily = daily_cost(prior_scope)
+
+        current_series = current_daily.sort.map { |date, cost| [date_to_ms(date), cost.round(6)] }
+        # Shift prior dates forward so they overlay on the same x-axis
+        prior_series = if prior_daily.any? && current_daily.any?
+          offset = (Date.parse(current_daily.keys.min) - Date.parse(prior_daily.keys.min)).to_i
+          prior_daily.sort.map { |date, cost| [date_to_ms(date, offset_days: offset), cost.round(6)] }
+        else
+          []
+        end
+
+        {
+          series: [
+            {name: "Current period", data: current_series, type: "areaspline"},
+            {name: "Prior period", data: prior_series, type: "spline", dashStyle: "Dash"}
+          ]
+        }
+      end
+
+      def daily_cost(scope)
+        scope.select(
+          Arel.sql("#{date_bucket_sql} AS bucket"),
+          Arel.sql("COALESCE(SUM(total_cost), 0) AS sum_cost")
+        ).group(Arel.sql("bucket"))
+          .each_with_object({}) { |row, h| h[row["bucket"].to_s] = row["sum_cost"].to_f }
+      end
+
+      def date_to_ms(date_str, offset_days: 0)
+        (Date.parse(date_str) + offset_days.days).strftime("%s").to_i * 1000
+      end
+    end
+  end
+end

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

@@ -23,13 +23,15 @@ module RubyLLM
 
         if params[:q].present?
           @search_query = params[:q].to_s.strip
+          escaped = TenantBudget.sanitize_sql_like(@search_query)
           scope = scope.where(
-            "tenant_id LIKE :q OR name LIKE :q",
-            q: "%#{TenantBudget.sanitize_sql_like(@search_query)}%"
+            "tenant_id LIKE :q OR name LIKE :q OR tenant_record_type LIKE :q OR tenant_record_id LIKE :q",
+            q: "%#{escaped}%"
           )
         end
 
         @tenants = scope.order(@sort_params[:column] => @sort_params[:direction].to_sym)
+        preload_tenant_index_data
       end
 
       # Shows a single tenant's budget details
@@ -39,6 +41,9 @@ module RubyLLM
         @tenant = TenantBudget.find(params[:id])
         @executions = tenant_executions(@tenant.tenant_id).recent.limit(10)
         @usage_stats = calculate_usage_stats(@tenant)
+        @usage_by_agent = @tenant.usage_by_agent(period: nil)
+        @usage_by_model = @tenant.usage_by_model(period: nil)
+        load_tenant_analytics
       end
 
       # Renders the edit form for a tenant budget
@@ -48,6 +53,15 @@ module RubyLLM
         @tenant = TenantBudget.find(params[:id])
       end
 
+      # Recalculates budget counters from the executions table
+      #
+      # @return [void]
+      def refresh_counters
+        @tenant = TenantBudget.find(params[:id])
+        @tenant.refresh_counters!
+        redirect_to tenant_path(@tenant), notice: "Counters refreshed"
+      end
+
       # Updates a tenant budget
       #
       # @return [void]
@@ -110,6 +124,64 @@ module RubyLLM
         }
       end
 
+      # Loads trend data and period comparison for the tenant analytics section.
+      #
+      # @return [void]
+      def load_tenant_analytics
+        # 30-day daily cost/tokens trend
+        @daily_trend = @tenant.usage_by_day(period: 30.days.ago..Time.current)
+
+        # Period comparison: this month vs last month
+        this_month = @tenant.usage_summary(period: :this_month)
+        last_month = @tenant.usage_summary(period: :last_month)
+        @period_comparison = {
+          this_month: this_month,
+          last_month: last_month,
+          cost_change: percent_change(last_month[:cost], this_month[:cost]),
+          tokens_change: percent_change(last_month[:tokens], this_month[:tokens]),
+          executions_change: percent_change(last_month[:executions], this_month[:executions]),
+          avg_cost_this: (this_month[:executions] > 0) ? (this_month[:cost].to_f / this_month[:executions]) : 0,
+          avg_cost_last: (last_month[:executions] > 0) ? (last_month[:cost].to_f / last_month[:executions]) : 0
+        }
+        @period_comparison[:avg_cost_change] = percent_change(
+          @period_comparison[:avg_cost_last], @period_comparison[:avg_cost_this]
+        )
+
+        # Error cost: money spent on failed executions
+        error_scope = @tenant.executions.where(status: "error")
+        @error_cost = error_scope.sum(:total_cost) || 0
+        @error_count = error_scope.count
+      end
+
+      # Calculates percentage change between two values
+      #
+      # @return [Float]
+      def percent_change(old_val, new_val)
+        return 0.0 if old_val.nil? || old_val.to_f.zero?
+        ((new_val.to_f - old_val.to_f) / old_val.to_f * 100).round(1)
+      end
+
+      # Preloads cost and last-execution data for all tenants in one query each,
+      # avoiding N+1 queries in the index view.
+      #
+      # @return [void]
+      def preload_tenant_index_data
+        @tenant_costs = {}
+        @tenant_last_executions = {}
+        tenant_ids = @tenants.map(&:tenant_id)
+        return if tenant_ids.empty?
+
+        # Batch-load total cost per tenant
+        @tenant_costs = Execution.where(tenant_id: tenant_ids)
+          .group(:tenant_id)
+          .sum(:total_cost)
+
+        # Batch-load last execution time per tenant
+        @tenant_last_executions = Execution.where(tenant_id: tenant_ids)
+          .group(:tenant_id)
+          .maximum(:created_at)
+      end
+
       # Parses and validates sort parameters for tenants list
       #
       # @return [Hash] Contains :column and :direction keys

data/app/models/ruby_llm/agents/agent_override.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Stores dashboard-managed overrides for agent settings.
+    #
+    # When an agent declares a field as `overridable: true` in its DSL,
+    # the dashboard can persist an override value in this table. The DSL
+    # getter merges the override on top of the code-defined default.
+    #
+    # Each row maps one agent class name to a JSON hash of overridden fields.
+    #
+    # @example
+    #   AgentOverride.create!(
+    #     agent_type: "SupportAgent",
+    #     settings: { "model" => "claude-sonnet-4-5", "temperature" => 0.3 }
+    #   )
+    #
+    # @see DSL::Base#resolve_override
+    # @api private
+    class AgentOverride < ::ActiveRecord::Base
+      self.table_name = "ruby_llm_agents_overrides"
+
+      validates :agent_type, presence: true, uniqueness: true
+
+      after_save :bust_agent_cache
+      after_destroy :bust_agent_cache
+
+      # Returns the override value for a single field, or nil
+      #
+      # @param field [Symbol, String] The field name
+      # @return [Object, nil] The override value
+      def [](field)
+        (settings || {})[field.to_s]
+      end
+
+      private
+
+      # Clears the in-memory override cache on the agent class so the
+      # next call picks up the new values.
+      def bust_agent_cache
+        klass = agent_type.safe_constantize
+        klass&.clear_override_cache! if klass.respond_to?(:clear_override_cache!)
+      end
+    end
+  end
+end

data/app/models/ruby_llm/agents/execution/analytics.rb

@@ -30,16 +30,31 @@ module RubyLLM
           def daily_report
             scope = today
 
+            # Single aggregated query for core metrics
+            total, successful, failed, cost, tokens, avg_dur, avg_tok = scope.pick(
+              Arel.sql("COUNT(*)"),
+              Arel.sql("SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END)"),
+              Arel.sql("SUM(CASE WHEN status IN ('error','timeout') THEN 1 ELSE 0 END)"),
+              Arel.sql("COALESCE(SUM(total_cost), 0)"),
+              Arel.sql("COALESCE(SUM(total_tokens), 0)"),
+              Arel.sql("AVG(duration_ms)"),
+              Arel.sql("AVG(total_tokens)")
+            )
+
+            total = total.to_i
+            successful = successful.to_i
+            failed = failed.to_i
+
             {
               date: Date.current,
-              total_executions: scope.count,
-              successful: scope.successful.count,
-              failed: scope.failed.count,
-              total_cost: scope.total_cost_sum || 0,
-              total_tokens: scope.total_tokens_sum || 0,
-              avg_duration_ms: scope.avg_duration&.round || 0,
-              avg_tokens: scope.avg_tokens&.round || 0,
-              error_rate: calculate_error_rate(scope),
+              total_executions: total,
+              successful: successful,
+              failed: failed,
+              total_cost: cost.to_f,
+              total_tokens: tokens.to_i,
+              avg_duration_ms: avg_dur.to_i,
+              avg_tokens: avg_tok.to_i,
+              error_rate: (total > 0) ? (failed.to_f / total * 100).round(2) : 0.0,
               by_agent: scope.group(:agent_type).count,
               top_errors: scope.errors.group(:error_class).count.sort_by { |_, v| -v }.first(5).to_h
             }
@@ -89,19 +104,25 @@ module RubyLLM
           # @return [Array<Hash>] Daily metrics sorted oldest to newest
           def trend_analysis(agent_type: nil, days: 7)
             scope = agent_type ? by_agent(agent_type) : all
+            end_date = Date.current
+            start_date = end_date - (days - 1).days
+
+            time_scope = scope.where(created_at: start_date.beginning_of_day..end_date.end_of_day)
+            results = aggregated_chart_query(time_scope, granularity: :day)
 
-            (0...days).map do |days_ago|
-              date = days_ago.days.ago.to_date
-              day_scope = scope.where(created_at: date.beginning_of_day..date.end_of_day)
+            (0...days).map do |i|
+              date = start_date + i.days
+              key = date.to_s
+              row = results[key] || {success: 0, failed: 0, cost: 0.0, duration: 0, tokens: 0}
 
               {
                 date: date,
-                count: day_scope.count,
-                total_cost: day_scope.total_cost_sum || 0,
-                avg_duration_ms: day_scope.avg_duration&.round || 0,
-                error_count: day_scope.failed.count
+                count: row[:success] + row[:failed],
+                total_cost: row[:cost],
+                avg_duration_ms: row[:duration],
+                error_count: row[:failed]
               }
-            end.reverse
+            end
           end
 
           # Builds hourly activity chart data for today

data/app/services/ruby_llm/agents/agent_registry.rb

@@ -70,7 +70,14 @@ module RubyLLM
           }
 
           type = detect_agent_type(agent_class)
-          base.merge(type_config_for(agent_class, type))
+          config = base.merge(type_config_for(agent_class, type))
+
+          # Include dashboard override metadata
+          config[:overridable_fields] = safe_call(agent_class, :overridable_fields) || []
+          config[:active_overrides] = safe_call(agent_class, :active_overrides) || {}
+          config[:has_overrides] = config[:active_overrides].any?
+
+          config
         end
 
         private

data/app/views/layouts/ruby_llm/agents/application.html.erb

@@ -296,7 +296,8 @@
             [ruby_llm_agents.root_path, "dashboard"],
             [ruby_llm_agents.agents_path, "agents"],
             [ruby_llm_agents.executions_path, "executions"],
-            [ruby_llm_agents.requests_path, "requests"]
+            [ruby_llm_agents.requests_path, "requests"],
+            [ruby_llm_agents.analytics_path, "analytics"]
           ]
           nav_items << [ruby_llm_agents.tenants_path, "tenants"] if tenant_filter_enabled?
           nav_items.each do |path, label| %>
@@ -347,7 +348,8 @@
             [ruby_llm_agents.root_path, "dashboard"],
             [ruby_llm_agents.agents_path, "agents"],
             [ruby_llm_agents.executions_path, "executions"],
-            [ruby_llm_agents.requests_path, "requests"]
+            [ruby_llm_agents.requests_path, "requests"],
+            [ruby_llm_agents.analytics_path, "analytics"]
           ]
           mobile_nav_items << [ruby_llm_agents.tenants_path, "tenants"] if tenant_filter_enabled?
           mobile_nav_items.each do |path, label| %>