ruby_llm-agents 3.15.1 → 3.16.0

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

@@ -153,9 +153,9 @@ module RubyLLM
                 joined.where("json_extract(#{detail_table}.parameters, ?) IS NOT NULL", "$.#{key}")
               end
             elsif value
-              joined.where("#{detail_table}.parameters @> ?", {key => value}.to_json)
+              joined.where("#{detail_table}.parameters::jsonb @> ?", {key => value}.to_json)
             else
-              joined.where("#{detail_table}.parameters ? :key", key: key.to_s)
+              joined.where("#{detail_table}.parameters::jsonb ? :key", key: key.to_s)
             end
           end
 
@@ -338,7 +338,7 @@ module RubyLLM
             if connection.adapter_name.downcase.include?("sqlite")
               where("json_extract(metadata, ?) = 1", "$.#{key}")
             else
-              where("metadata @> ?", {key.to_s => true}.to_json)
+              where("metadata::jsonb @> ?", {key.to_s => true}.to_json)
             end
           end
 
@@ -355,6 +355,42 @@ module RubyLLM
             end
           end
 
+          # Distinct non-null values of a column, sorted
+          #
+          # `SELECT DISTINCT col` reads every row (or every index entry) to
+          # return a handful of values, which takes seconds on a table with
+          # millions of executions, and PostgreSQL before 18 has no skip scan
+          # to avoid it. When an index leads with the column this walks the
+          # index instead: take the smallest value, then repeatedly the
+          # smallest value greater than the last one. The cost is one index
+          # probe per distinct value, whatever the row count.
+          #
+          # Falls back to a plain DISTINCT when called on anything narrower
+          # than the whole table (the walk would ignore the filter) or when no
+          # index leads with the column (each probe would be a full scan).
+          #
+          # @param column [Symbol, String] A column of the executions table
+          # @return [Array] Sorted distinct values, nil excluded
+          def distinct_values(column)
+            column = column.to_s
+            raise ArgumentError, "Unknown column: #{column}" unless column_names.include?(column)
+
+            walkable = all.to_sql == unscoped.to_sql &&
+              connection.schema_cache.indexes(table_name).any? { |index| Array(index.columns).first == column }
+            return where.not(column => nil).distinct.pluck(column).sort unless walkable
+
+            col = connection.quote_column_name(column)
+            connection.select_values(<<~SQL.squish, "#{name} Distinct Values").sort
+              WITH RECURSIVE walk(v) AS (
+                SELECT MIN(#{col}) FROM #{quoted_table_name}
+                UNION ALL
+                SELECT (SELECT MIN(#{col}) FROM #{quoted_table_name} WHERE #{col} > walk.v)
+                FROM walk WHERE walk.v IS NOT NULL
+              )
+              SELECT v FROM walk WHERE v IS NOT NULL
+            SQL
+          end
+
           # Returns sum of total_cost for the current scope
           #
           # @return [Float, nil] Total cost in USD

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

@@ -74,6 +74,18 @@ module RubyLLM
       has_one :detail, class_name: "RubyLLM::Agents::ExecutionDetail",
         foreign_key: :execution_id, dependent: :destroy
 
+      # Same row as :detail, but selecting only error_message.
+      #
+      # List and CSV views read nothing but the error message, while the full
+      # detail row carries prompts and response JSON that routinely run to
+      # hundreds of kilobytes each. Preloading :detail for a page of rows drags
+      # all of that into memory; preloading :error_detail costs a few bytes per
+      # row. Never use this association for anything but error_message — the
+      # other attributes are not selected and will raise.
+      has_one :error_detail, -> { select(:id, :execution_id, :error_message) },
+        class_name: "RubyLLM::Agents::ExecutionDetail",
+        foreign_key: :execution_id, inverse_of: false
+
       # Individual tool call records (real-time tracking)
       has_many :tool_executions, class_name: "RubyLLM::Agents::ToolExecution",
         foreign_key: :execution_id, dependent: :destroy
@@ -94,7 +106,8 @@ module RubyLLM
       #
       # @return [String, nil]
       def error_message
-        detail&.error_message || metadata&.dig("error_message")
+        row = association(:detail).loaded? ? detail : error_detail
+        row&.error_message || metadata&.dig("error_message")
       end
 
       # Validations
@@ -348,8 +361,11 @@ module RubyLLM
       # instead of ~15 individual count/sum/average queries.
       #
       # @param range [String] Time range: "today", "7d", "30d", or "90d"
+      # @param current [Hash, nil] Stats for the current period, when the caller
+      #   already has them (a {Breakdown#totals} of the same window) — saves
+      #   scanning that window a second time
       # @return [Hash] Now strip metrics with period-over-period comparisons
-      def self.now_strip_data(range: "today")
+      def self.now_strip_data(range: "today", current: nil)
         current_scope = case range
         when "7d" then last_n_days(7)
         when "30d" then last_n_days(30)
@@ -364,7 +380,7 @@ module RubyLLM
         else yesterday
         end
 
-        curr = aggregate_period_stats(current_scope)
+        curr = current || aggregate_period_stats(current_scope)
         prev = aggregate_period_stats(previous_scope)
 
         {
@@ -395,15 +411,17 @@ module RubyLLM
       #
       # @param from [Date] Start date (inclusive)
       # @param to [Date] End date (inclusive)
+      # @param current [Hash, nil] Precomputed stats for the selected range (see
+      #   {.now_strip_data})
       # @return [Hash] Now strip metrics with period-over-period comparisons
-      def self.now_strip_data_for_dates(from:, to:)
+      def self.now_strip_data_for_dates(from:, to:, current: nil)
         span_days = (to - from).to_i + 1
         current_scope = where(created_at: from.beginning_of_day..to.end_of_day)
         previous_from = from - span_days.days
         previous_to = from - 1.day
         previous_scope = where(created_at: previous_from.beginning_of_day..previous_to.end_of_day)
 
-        curr = aggregate_period_stats(current_scope)
+        curr = current || aggregate_period_stats(current_scope)
         prev = aggregate_period_stats(previous_scope)
 
         {

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

@@ -21,6 +21,14 @@ module RubyLLM
     #
     # @api public
     class AgentRegistry
+      # Window the per-agent stats in {.all_with_details} cover
+      #
+      # All-time stats mean reading the whole executions table, which stops
+      # being viable in the millions of rows. A recent window keeps the list
+      # proportional to current traffic, and is the more useful health signal
+      # anyway.
+      STATS_WINDOW = 30.days
+
       class << self
         # Returns all unique agent type names
         #
@@ -47,10 +55,18 @@ module RubyLLM
 
         # Returns detailed info about all agents
         #
+        # Usage figures (:execution_count, :total_cost, :total_tokens,
+        # :avg_duration_ms, :success_rate, :error_rate) cover the last
+        # STATS_WINDOW and come from one grouped query shared by every agent.
+        # They are nil when that query could not finish within
+        # config.dashboard_query_timeout. :last_executed is all-time.
+        #
         # @return [Array<Hash>] Agent info hashes with configuration and stats
         def all_with_details
+          recent = recent_usage
+
           all.map do |agent_type|
-            build_agent_info(agent_type)
+            build_agent_info(agent_type, recent)
           end
         end
 
@@ -183,9 +199,16 @@ module RubyLLM
 
         # Finds agent types from execution history
         #
+        # Cached briefly: it only exists to keep deleted agents visible, so a
+        # few minutes of staleness is invisible.
+        #
         # @return [Array<String>] Agent class names with execution records
         def execution_agents
-          Execution.distinct.pluck(:agent_type).compact
+          Rails.cache.fetch(["ruby_llm_agents", "agent_registry", "execution_agents"], expires_in: 5.minutes) do
+            Execution.distinct_values(:agent_type)
+          end
+        rescue ::ActiveRecord::QueryCanceled
+          raise
         rescue => e
           Rails.logger.error("[RubyLLM::Agents] Error loading agents from executions: #{e.message}")
           []
@@ -213,10 +236,11 @@ module RubyLLM
         # Builds detailed info hash for an agent
         #
         # @param agent_type [String] The agent class name
+        # @param recent [Execution::Breakdown, nil] Usage over STATS_WINDOW
         # @return [Hash] Agent info including config and stats
-        def build_agent_info(agent_type)
+        def build_agent_info(agent_type, recent)
           agent_class = find(agent_type)
-          stats = fetch_stats(agent_type)
+          stats = fetch_stats(agent_type, recent)
 
           # Detect the agent type (agent, embedder, speaker, transcriber, image_generator)
           detected_type = detect_agent_type(agent_class)
@@ -240,7 +264,7 @@ module RubyLLM
             avg_duration_ms: stats[:avg_duration_ms],
             success_rate: stats[:success_rate],
             error_rate: stats[:error_rate],
-            last_executed: last_execution_time(agent_type)
+            last_executed: stats[:last_seen] || last_execution_time(agent_type)
           }
         end
 
@@ -258,22 +282,61 @@ module RubyLLM
           nil
         end
 
-        # Fetches statistics for an agent
+        # Usage of every agent over STATS_WINDOW, from one grouped query
+        #
+        # Cached, since the agents list is the same for everyone looking at
+        # it, and best-effort: nil (also cached) when the database cannot
+        # answer within config.dashboard_query_timeout.
+        #
+        # @return [Execution::Breakdown, nil]
+        def recent_usage
+          rows = Rails.cache.fetch(["ruby_llm_agents", "agent_registry", "recent_usage"], expires_in: 5.minutes) do
+            Execution.best_effort(timeout: RubyLLM::Agents.configuration.dashboard_query_timeout) do
+              Execution.where("created_at >= ?", STATS_WINDOW.ago).breakdown.rows
+            end
+          end
+
+          rows && Execution::Breakdown.new(rows)
+        rescue => e
+          Rails.logger.error("[RubyLLM::Agents] Error loading agent stats: #{e.message}")
+          nil
+        end
+
+        # Picks one agent's statistics out of the shared usage breakdown
+        #
+        # Executions recorded under the agent's previous names (aliases) count
+        # towards it.
         #
         # @param agent_type [String] The agent class name
-        # @return [Hash] Statistics hash
-        def fetch_stats(agent_type)
-          Execution.stats_for(agent_type, period: :all_time)
-        rescue
-          {count: 0, total_cost: 0, total_tokens: 0, avg_duration_ms: 0, success_rate: 0, error_rate: 0}
+        # @param recent [Execution::Breakdown, nil] Usage over STATS_WINDOW
+        # @return [Hash] Statistics hash; values are nil when usage is unavailable
+        def fetch_stats(agent_type, recent)
+          return {} unless recent
+
+          totals = recent.for_agents(Execution.resolve_agent_names(agent_type)).totals
+
+          {
+            count: totals[:total],
+            total_cost: totals[:cost],
+            total_tokens: totals[:tokens],
+            avg_duration_ms: totals[:avg_duration_ms],
+            success_rate: totals[:success_rate],
+            error_rate: totals[:error_rate],
+            last_seen: totals[:last_seen]
+          }
         end
 
         # Gets the timestamp of the last execution for an agent
         #
+        # Only needed for agents with no runs inside STATS_WINDOW. One index
+        # probe per name the agent has gone by.
+        #
         # @param agent_type [String] The agent class name
         # @return [Time, nil] Last execution time or nil
         def last_execution_time(agent_type)
-          Execution.by_agent(agent_type).order(created_at: :desc).first&.created_at
+          Execution.resolve_agent_names(agent_type)
+            .filter_map { |name| Execution.where(agent_type: name).maximum(:created_at) }
+            .max
         rescue
           nil
         end

data/app/views/ruby_llm/agents/agents/index.html.erb

@@ -42,6 +42,11 @@
       <span x-text="currentCount"></span>
       <%= render "ruby_llm/agents/shared/doc_link" %>
     </div>
+    <% if @stats_available %>
+      <span class="font-mono text-[10px] text-gray-400 dark:text-gray-600">runs, cost and ok% cover the last <%= @stats_window_days %> days</span>
+    <% else %>
+      <span class="font-mono text-[10px] text-yellow-600 dark:text-yellow-500" role="status">usage stats took too long to load and were skipped</span>
+    <% end %>
     <div class="flex-1 border-t border-gray-200 dark:border-gray-800"></div>
     <div class="flex font-mono text-xs gap-0.5">
       <button type="button" @click="activeSubTab = null; updateUrl()"
@@ -108,7 +113,7 @@
             "activeSubTab !== 'deleted' && (activeSubTab === null || activeSubTab === '#{agent[:agent_type]}')"
           end
           success_rate = agent[:success_rate] || 0
-          dot_color = agent[:active] ? (success_rate >= 95 ? 'bg-green-500' : success_rate >= 80 ? 'bg-yellow-500' : 'bg-red-500') : 'bg-gray-400'
+          dot_color = !agent[:active] || !@stats_available ? 'bg-gray-400' : (success_rate >= 95 ? 'bg-green-500' : success_rate >= 80 ? 'bg-yellow-500' : 'bg-red-500')
         %>
         <div x-show="<%= show_condition %>"
              class="group flex items-center gap-3 py-1.5 px-2 -mx-2 rounded hover:bg-gray-100 dark:hover:bg-gray-800/50 cursor-pointer"
@@ -120,9 +125,15 @@
           <span class="flex-1 min-w-0 truncate text-gray-500 dark:text-gray-400 hidden sm:inline"><%= agent[:agent_type]&.to_s || 'agent' %></span>
           <span class="w-1.5 h-1.5 rounded-full flex-shrink-0 <%= dot_color %>"></span>
           <span class="flex-[2] min-w-0 truncate text-gray-400 dark:text-gray-600 hidden lg:inline"><%= agent[:model]&.split("/")&.last || "—" %></span>
-          <span class="w-14 flex-shrink-0 text-right text-gray-500 dark:text-gray-400"><%= number_with_delimiter(agent[:execution_count] || 0) %><span class="text-gray-400 dark:text-gray-600">r</span></span>
-          <span class="w-16 flex-shrink-0 text-right text-gray-500 dark:text-gray-400 hidden md:inline">$<%= number_with_precision(agent[:total_cost] || 0, precision: 2) %></span>
-          <span class="w-12 flex-shrink-0 text-right <%= success_rate >= 95 ? 'text-green-500' : success_rate >= 80 ? 'text-yellow-500' : 'text-red-500' %>"><%= success_rate.round %>%</span>
+          <% if @stats_available %>
+            <span class="w-14 flex-shrink-0 text-right text-gray-500 dark:text-gray-400"><%= number_with_delimiter(agent[:execution_count] || 0) %><span class="text-gray-400 dark:text-gray-600">r</span></span>
+            <span class="w-16 flex-shrink-0 text-right text-gray-500 dark:text-gray-400 hidden md:inline">$<%= number_with_precision(agent[:total_cost] || 0, precision: 2) %></span>
+            <span class="w-12 flex-shrink-0 text-right <%= success_rate >= 95 ? 'text-green-500' : success_rate >= 80 ? 'text-yellow-500' : 'text-red-500' %>"><%= success_rate.round %>%</span>
+          <% else %>
+            <span class="w-14 flex-shrink-0 text-right text-gray-400 dark:text-gray-600">—</span>
+            <span class="w-16 flex-shrink-0 text-right text-gray-400 dark:text-gray-600 hidden md:inline">—</span>
+            <span class="w-12 flex-shrink-0 text-right text-gray-400 dark:text-gray-600">—</span>
+          <% end %>
           <span class="w-24 flex-shrink-0 text-gray-400 dark:text-gray-600 text-right whitespace-nowrap">
             <% if agent[:last_executed] %>
               <%= time_ago_in_words(agent[:last_executed]) %>
@@ -144,9 +155,15 @@
           <span class="flex-1 min-w-0 truncate text-gray-400 dark:text-gray-600 hidden sm:inline"><%= agent[:agent_type]&.to_s || 'agent' %></span>
           <span class="w-1.5 h-1.5 rounded-full flex-shrink-0 bg-gray-400 dark:bg-gray-600"></span>
           <span class="flex-[2] min-w-0 truncate text-gray-400 dark:text-gray-600 hidden lg:inline"><%= agent[:model]&.split("/")&.last || "—" %></span>
-          <span class="w-14 flex-shrink-0 text-right text-gray-400 dark:text-gray-600"><%= number_with_delimiter(agent[:execution_count] || 0) %><span class="text-gray-400 dark:text-gray-600">r</span></span>
-          <span class="w-16 flex-shrink-0 text-right text-gray-400 dark:text-gray-600 hidden md:inline">$<%= number_with_precision(agent[:total_cost] || 0, precision: 2) %></span>
-          <span class="w-12 flex-shrink-0 text-right text-gray-400 dark:text-gray-600"><%= success_rate.round %>%</span>
+          <% if @stats_available %>
+            <span class="w-14 flex-shrink-0 text-right text-gray-400 dark:text-gray-600"><%= number_with_delimiter(agent[:execution_count] || 0) %><span class="text-gray-400 dark:text-gray-600">r</span></span>
+            <span class="w-16 flex-shrink-0 text-right text-gray-400 dark:text-gray-600 hidden md:inline">$<%= number_with_precision(agent[:total_cost] || 0, precision: 2) %></span>
+            <span class="w-12 flex-shrink-0 text-right text-gray-400 dark:text-gray-600"><%= success_rate.round %>%</span>
+          <% else %>
+            <span class="w-14 flex-shrink-0 text-right text-gray-400 dark:text-gray-600">—</span>
+            <span class="w-16 flex-shrink-0 text-right text-gray-400 dark:text-gray-600 hidden md:inline">—</span>
+            <span class="w-12 flex-shrink-0 text-right text-gray-400 dark:text-gray-600">—</span>
+          <% end %>
           <span class="w-24 flex-shrink-0 text-gray-400 dark:text-gray-600 text-right whitespace-nowrap">
             <% if agent[:last_executed] %>
               <%= time_ago_in_words(agent[:last_executed]) %>

data/app/views/ruby_llm/agents/agents/show.html.erb

@@ -75,6 +75,7 @@
   <div class="flex-shrink-0 text-right font-mono text-xs text-gray-400 dark:text-gray-500 space-y-1">
     <% success_rate = @stats[:success_rate] || 0 %>
     <div class="flex items-center justify-end gap-x-4">
+      <span class="text-gray-300 dark:text-gray-700"><%= @stats_window_days %>d</span>
       <span><span class="text-gray-800 dark:text-gray-200"><%= number_with_delimiter(@stats[:count]) %></span> runs</span>
       <span class="<%= success_rate >= 95 ? 'text-green-500' : success_rate >= 80 ? 'text-yellow-500' : 'text-red-500' %>"><%= success_rate %>% ok</span>
       <span><span class="text-gray-800 dark:text-gray-200">$<%= number_with_precision(@stats[:total_cost] || 0, precision: 4) %></span> cost</span>
@@ -311,11 +312,11 @@
 
 <%= render "ruby_llm/agents/shared/executions_table", executions: @executions, pagination: @pagination, hide_agent_column: true %>
 
-<% if @stats[:count] > 0 %>
+<% if @executions.any? %>
   <div class="mt-3 font-mono text-xs">
     <%= link_to ruby_llm_agents.executions_path("agent_types[]": @agent_type),
         class: "text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" do %>
-      show all <%= number_with_delimiter(@stats[:count]) %> executions →
+      show all executions →
     <% end %>
   </div>
 <% end %>

data/app/views/ruby_llm/agents/executions/_filters.html.erb

@@ -156,13 +156,18 @@
         <%# Stats %>
         <div id="filter-stats" class="flex items-center justify-between md:justify-end gap-2 py-2 px-3 md:p-0 bg-gray-50 md:bg-transparent dark:bg-gray-700/50 md:dark:bg-transparent rounded-lg md:rounded-none">
           <span class="text-xs text-gray-400 dark:text-gray-500 md:hidden">Results</span>
-          <div class="flex items-center gap-2 text-xs text-gray-400 dark:text-gray-500">
-            <span class="tabular-nums"><%= number_to_human_short(filter_stats[:total_count]) %><span class="md:hidden"> executions</span></span>
-            <span class="text-gray-300 dark:text-gray-600">/</span>
-            <span class="tabular-nums"><%= number_to_human_short(filter_stats[:total_cost], prefix: "$", precision: 2) %></span>
-            <span class="hidden md:inline text-gray-300 dark:text-gray-600">/</span>
-            <span class="hidden md:inline tabular-nums"><%= number_to_human_short(filter_stats[:total_tokens]) %>t</span>
-          </div>
+          <% if filter_stats %>
+            <div class="flex items-center gap-2 text-xs text-gray-400 dark:text-gray-500">
+              <span class="tabular-nums"><%= number_to_human_short(filter_stats[:total_count]) %><span class="md:hidden"> executions</span></span>
+              <span class="text-gray-300 dark:text-gray-600">/</span>
+              <span class="tabular-nums"><%= number_to_human_short(filter_stats[:total_cost], prefix: "$", precision: 2) %></span>
+              <span class="hidden md:inline text-gray-300 dark:text-gray-600">/</span>
+              <span class="hidden md:inline tabular-nums"><%= number_to_human_short(filter_stats[:total_tokens]) %>t</span>
+            </div>
+          <% else %>
+            <span class="text-xs text-gray-400 dark:text-gray-500 cursor-help"
+                  title="Too many executions match to total them quickly. Pick a time range to see totals.">totals: pick a time range</span>
+          <% end %>
         </div>
 
         <%# Actions %>

data/app/views/ruby_llm/agents/executions/_list.html.erb

@@ -77,57 +77,6 @@
       <% end %>
     </div>
 
-    <%# Pagination %>
-    <% if pagination && pagination[:total_pages] > 1 %>
-      <%
-        current_page = pagination[:current_page]
-        total_pages = pagination[:total_pages]
-        total_count = pagination[:total_count]
-        per_page = pagination[:per_page]
-        from_record = ((current_page - 1) * per_page) + 1
-        to_record = [current_page * per_page, total_count].min
-      %>
-      <div class="flex items-center justify-between font-mono text-xs mt-4 pt-4 border-t border-gray-200 dark:border-gray-800">
-        <span class="text-gray-400 dark:text-gray-600"><%= from_record %>-<%= to_record %> of <%= number_with_delimiter(total_count) %></span>
-        <nav class="flex items-center gap-1">
-          <% if current_page > 1 %>
-            <%= link_to "prev", url_for(request.query_parameters.merge(page: current_page - 1)),
-                class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-          <% else %>
-            <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">prev</span>
-          <% end %>
-
-          <%
-            window = 2
-            pages_to_show = []
-            (1..total_pages).each do |page|
-              if page <= 1 || page >= total_pages || (page >= current_page - window && page <= current_page + window)
-                pages_to_show << page
-              elsif pages_to_show.last != :gap
-                pages_to_show << :gap
-              end
-            end
-          %>
-
-          <% pages_to_show.each do |page| %>
-            <% if page == :gap %>
-              <span class="px-1 text-gray-400 dark:text-gray-600">...</span>
-            <% elsif page == current_page %>
-              <span class="px-2 py-0.5 text-gray-900 dark:text-gray-100"><%= page %></span>
-            <% else %>
-              <%= link_to page, url_for(request.query_parameters.merge(page: page)),
-                  class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-            <% end %>
-          <% end %>
-
-          <% if current_page < total_pages %>
-            <%= link_to "next", url_for(request.query_parameters.merge(page: current_page + 1)),
-                class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-          <% else %>
-            <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">next</span>
-          <% end %>
-        </nav>
-      </div>
-    <% end %>
+    <%= render "ruby_llm/agents/shared/pagination", pagination: pagination, shown: executions.size if pagination %>
   <% end %>
 </div>

data/app/views/ruby_llm/agents/requests/index.html.erb

@@ -1,11 +1,13 @@
 <div class="flex items-center gap-3 mb-6">
   <span class="text-[10px] font-medium text-gray-400 dark:text-gray-600 uppercase tracking-widest font-mono">requests</span>
   <div class="flex-1 border-t border-gray-200 dark:border-gray-800"></div>
-  <span class="font-mono text-[10px] text-gray-400 dark:text-gray-600">
-    <%= number_with_delimiter(@stats[:total_requests]) %> tracked
-    &middot;
-    $<%= number_with_precision(@stats[:total_cost] || 0, precision: 4) %> total
-  </span>
+  <% if @stats %>
+    <span class="font-mono text-[10px] text-gray-400 dark:text-gray-600">
+      <%= number_with_delimiter(@stats[:total_requests]) %> tracked
+      &middot;
+      $<%= number_with_precision(@stats[:total_cost] || 0, precision: 4) %> total
+    </span>
+  <% end %>
 </div>
 
 <%
@@ -98,56 +100,5 @@
     <% end %>
   </div>
 
-  <%# Pagination %>
-  <% if @pagination && @pagination[:total_pages] > 1 %>
-    <%
-      current_page = @pagination[:current_page]
-      total_pages = @pagination[:total_pages]
-      total_count = @pagination[:total_count]
-      per_page = @pagination[:per_page]
-      from_record = ((current_page - 1) * per_page) + 1
-      to_record = [current_page * per_page, total_count].min
-    %>
-    <div class="flex items-center justify-between font-mono text-xs mt-4 pt-4 border-t border-gray-200 dark:border-gray-800">
-      <span class="text-gray-400 dark:text-gray-600"><%= from_record %>-<%= to_record %> of <%= number_with_delimiter(total_count) %></span>
-      <nav class="flex items-center gap-1">
-        <% if current_page > 1 %>
-          <%= link_to "prev", url_for(request.query_parameters.merge(page: current_page - 1)),
-              class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-        <% else %>
-          <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">prev</span>
-        <% end %>
-
-        <%
-          window = 2
-          pages_to_show = []
-          (1..total_pages).each do |page|
-            if page <= 1 || page >= total_pages || (page >= current_page - window && page <= current_page + window)
-              pages_to_show << page
-            elsif pages_to_show.last != :gap
-              pages_to_show << :gap
-            end
-          end
-        %>
-
-        <% pages_to_show.each do |page| %>
-          <% if page == :gap %>
-            <span class="px-1 text-gray-400 dark:text-gray-600">...</span>
-          <% elsif page == current_page %>
-            <span class="px-2 py-0.5 text-gray-900 dark:text-gray-100"><%= page %></span>
-          <% else %>
-            <%= link_to page, url_for(request.query_parameters.merge(page: page)),
-                class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-          <% end %>
-        <% end %>
-
-        <% if current_page < total_pages %>
-          <%= link_to "next", url_for(request.query_parameters.merge(page: current_page + 1)),
-              class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-        <% else %>
-          <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">next</span>
-        <% end %>
-      </nav>
-    </div>
-  <% end %>
+  <%= render "ruby_llm/agents/shared/pagination", pagination: @pagination, shown: @requests.size if @pagination %>
 <% end %>

data/app/views/ruby_llm/agents/shared/_executions_table.html.erb

@@ -63,56 +63,5 @@
     <% end %>
   </div>
 
-  <%# Pagination %>
-  <% if pagination[:total_pages] > 1 %>
-    <%
-      current_page = pagination[:current_page]
-      total_pages = pagination[:total_pages]
-      total_count = pagination[:total_count]
-      per_page = pagination[:per_page]
-      from_record = ((current_page - 1) * per_page) + 1
-      to_record = [current_page * per_page, total_count].min
-    %>
-    <div class="flex items-center justify-between font-mono text-xs mt-4 pt-4 border-t border-gray-200 dark:border-gray-800">
-      <span class="text-gray-400 dark:text-gray-600"><%= from_record %>-<%= to_record %> of <%= number_with_delimiter(total_count) %></span>
-      <nav class="flex items-center gap-1">
-        <% if current_page > 1 %>
-          <%= link_to "prev", url_for(request.query_parameters.merge(page: current_page - 1)),
-              class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-        <% else %>
-          <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">prev</span>
-        <% end %>
-
-        <%
-          window = 2
-          pages_to_show = []
-          (1..total_pages).each do |page|
-            if page <= 1 || page >= total_pages || (page >= current_page - window && page <= current_page + window)
-              pages_to_show << page
-            elsif pages_to_show.last != :gap
-              pages_to_show << :gap
-            end
-          end
-        %>
-
-        <% pages_to_show.each do |page| %>
-          <% if page == :gap %>
-            <span class="px-1 text-gray-400 dark:text-gray-600">...</span>
-          <% elsif page == current_page %>
-            <span class="px-2 py-0.5 text-gray-900 dark:text-gray-100"><%= page %></span>
-          <% else %>
-            <%= link_to page, url_for(request.query_parameters.merge(page: page)),
-                class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-          <% end %>
-        <% end %>
-
-        <% if current_page < total_pages %>
-          <%= link_to "next", url_for(request.query_parameters.merge(page: current_page + 1)),
-              class: "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300" %>
-        <% else %>
-          <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">next</span>
-        <% end %>
-      </nav>
-    </div>
-  <% end %>
+  <%= render "ruby_llm/agents/shared/pagination", pagination: pagination, shown: executions.size %>
 <% end %>

data/app/views/ruby_llm/agents/shared/_pagination.html.erb

@@ -0,0 +1,66 @@
+<%#
+  Pagination links for a list page.
+
+  pagination: the hash built by Paginatable#paginate. When :total_count is
+  known this renders "1-25 of 1,234" with numbered pages; when it is not
+  (counting was skipped or timed out on a very large table) it renders the
+  current range with prev/next only.
+%>
+<%
+  current_page = pagination[:current_page]
+  per_page = pagination[:per_page]
+  total_count = pagination[:total_count]
+  total_pages = pagination[:total_pages]
+  has_next = total_pages ? current_page < total_pages : pagination[:next_page]
+  from_record = ((current_page - 1) * per_page) + 1
+  link_class = "px-2 py-0.5 text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300"
+%>
+<% if current_page > 1 || has_next %>
+  <div class="flex items-center justify-between font-mono text-xs mt-4 pt-4 border-t border-gray-200 dark:border-gray-800">
+    <span class="text-gray-400 dark:text-gray-600">
+      <% if total_count %>
+        <%= from_record %>-<%= [current_page * per_page, total_count].min %> of <%= number_with_delimiter(total_count) %>
+      <% else %>
+        <%= number_with_delimiter(from_record) %>-<%= number_with_delimiter(from_record + local_assigns.fetch(:shown, per_page) - 1) %>
+      <% end %>
+    </span>
+    <nav class="flex items-center gap-1" aria-label="Pagination">
+      <% if current_page > 1 %>
+        <%= link_to "prev", url_for(request.query_parameters.merge(page: current_page - 1)), class: link_class %>
+      <% else %>
+        <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">prev</span>
+      <% end %>
+
+      <% if total_pages %>
+        <%
+          window = 2
+          pages_to_show = []
+          (1..total_pages).each do |page|
+            if page <= 1 || page >= total_pages || (page >= current_page - window && page <= current_page + window)
+              pages_to_show << page
+            elsif pages_to_show.last != :gap
+              pages_to_show << :gap
+            end
+          end
+        %>
+        <% pages_to_show.each do |page| %>
+          <% if page == :gap %>
+            <span class="px-1 text-gray-400 dark:text-gray-600">...</span>
+          <% elsif page == current_page %>
+            <span class="px-2 py-0.5 text-gray-900 dark:text-gray-100" aria-current="page"><%= page %></span>
+          <% else %>
+            <%= link_to page, url_for(request.query_parameters.merge(page: page)), class: link_class %>
+          <% end %>
+        <% end %>
+      <% else %>
+        <span class="px-2 py-0.5 text-gray-900 dark:text-gray-100" aria-current="page"><%= current_page %></span>
+      <% end %>
+
+      <% if has_next %>
+        <%= link_to "next", url_for(request.query_parameters.merge(page: current_page + 1)), class: link_class %>
+      <% else %>
+        <span class="px-2 py-0.5 text-gray-300 dark:text-gray-700">next</span>
+      <% end %>
+    </nav>
+  </div>
+<% end %>