ruby_llm-agents 3.7.2 → 3.9.0

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

@@ -269,11 +269,14 @@ module RubyLLM
       # Returns whether this execution made tool calls
       #
       # @return [Boolean] true if tool calls were made
-      def has_tool_calls?
+      def tool_calls?
         tool_calls_count.to_i > 0
       end
+      alias_method :has_tool_calls?, :tool_calls?
 
       # Returns real-time dashboard data for the Now Strip
+      # Optimized: 3 queries (current aggregate + previous aggregate + running count)
+      # instead of ~15 individual count/sum/average queries.
       #
       # @param range [String] Time range: "today", "7d", "30d", or "90d"
       # @return [Hash] Now strip metrics with period-over-period comparisons
@@ -292,38 +295,31 @@ module RubyLLM
         else yesterday
         end
 
-        current = {
-          running: running.count,
-          success_today: current_scope.status_success.count,
-          errors_today: current_scope.status_error.count,
-          timeouts_today: current_scope.status_timeout.count,
-          cost_today: current_scope.sum(:total_cost) || 0,
-          executions_today: current_scope.count,
-          success_rate: calculate_period_success_rate(current_scope),
-          avg_duration_ms: current_scope.avg_duration&.round || 0,
-          total_tokens: current_scope.total_tokens_sum || 0
-        }
-
-        previous = {
-          success: previous_scope.status_success.count,
-          errors: previous_scope.status_error.count,
-          cost: previous_scope.sum(:total_cost) || 0,
-          avg_duration_ms: previous_scope.avg_duration&.round || 0,
-          total_tokens: previous_scope.total_tokens_sum || 0
-        }
+        curr = aggregate_period_stats(current_scope)
+        prev = aggregate_period_stats(previous_scope)
 
-        current.merge(
+        {
+          running: running.count,
+          success_today: curr[:success],
+          errors_today: curr[:errors],
+          timeouts_today: curr[:timeouts],
+          cost_today: curr[:cost],
+          executions_today: curr[:total],
+          success_rate: curr[:success_rate],
+          avg_duration_ms: curr[:avg_duration_ms],
+          total_tokens: curr[:tokens],
           comparisons: {
-            success_change: pct_change(previous[:success], current[:success_today]),
-            errors_change: pct_change(previous[:errors], current[:errors_today]),
-            cost_change: pct_change(previous[:cost], current[:cost_today]),
-            duration_change: pct_change(previous[:avg_duration_ms], current[:avg_duration_ms]),
-            tokens_change: pct_change(previous[:total_tokens], current[:total_tokens])
+            success_change: pct_change(prev[:success], curr[:success]),
+            errors_change: pct_change(prev[:errors], curr[:errors]),
+            cost_change: pct_change(prev[:cost], curr[:cost]),
+            duration_change: pct_change(prev[:avg_duration_ms], curr[:avg_duration_ms]),
+            tokens_change: pct_change(prev[:tokens], curr[:tokens])
           }
-        )
+        }
       end
 
       # Returns Now Strip data for a custom date range
+      # Optimized: 3 queries instead of ~15.
       #
       # Compares the selected range against the same-length window
       # immediately preceding it.
@@ -338,35 +334,27 @@ module RubyLLM
         previous_to = from - 1.day
         previous_scope = where(created_at: previous_from.beginning_of_day..previous_to.end_of_day)
 
-        current = {
-          running: running.count,
-          success_today: current_scope.status_success.count,
-          errors_today: current_scope.status_error.count,
-          timeouts_today: current_scope.status_timeout.count,
-          cost_today: current_scope.sum(:total_cost) || 0,
-          executions_today: current_scope.count,
-          success_rate: calculate_period_success_rate(current_scope),
-          avg_duration_ms: current_scope.avg_duration&.round || 0,
-          total_tokens: current_scope.total_tokens_sum || 0
-        }
-
-        previous = {
-          success: previous_scope.status_success.count,
-          errors: previous_scope.status_error.count,
-          cost: previous_scope.sum(:total_cost) || 0,
-          avg_duration_ms: previous_scope.avg_duration&.round || 0,
-          total_tokens: previous_scope.total_tokens_sum || 0
-        }
+        curr = aggregate_period_stats(current_scope)
+        prev = aggregate_period_stats(previous_scope)
 
-        current.merge(
+        {
+          running: running.count,
+          success_today: curr[:success],
+          errors_today: curr[:errors],
+          timeouts_today: curr[:timeouts],
+          cost_today: curr[:cost],
+          executions_today: curr[:total],
+          success_rate: curr[:success_rate],
+          avg_duration_ms: curr[:avg_duration_ms],
+          total_tokens: curr[:tokens],
           comparisons: {
-            success_change: pct_change(previous[:success], current[:success_today]),
-            errors_change: pct_change(previous[:errors], current[:errors_today]),
-            cost_change: pct_change(previous[:cost], current[:cost_today]),
-            duration_change: pct_change(previous[:avg_duration_ms], current[:avg_duration_ms]),
-            tokens_change: pct_change(previous[:total_tokens], current[:total_tokens])
+            success_change: pct_change(prev[:success], curr[:success]),
+            errors_change: pct_change(prev[:errors], curr[:errors]),
+            cost_change: pct_change(prev[:cost], curr[:cost]),
+            duration_change: pct_change(prev[:avg_duration_ms], curr[:avg_duration_ms]),
+            tokens_change: pct_change(prev[:tokens], curr[:tokens])
           }
-        )
+        }
       end
 
       # Calculates percentage change between old and new values
@@ -390,6 +378,39 @@ module RubyLLM
         (scope.successful.count.to_f / total * 100).round(1)
       end
 
+      # Returns aggregate stats for a scope in a single query using conditional aggregation
+      #
+      # Replaces ~9 individual count/sum/average queries with one SQL query.
+      #
+      # @param scope [ActiveRecord::Relation] Time-filtered scope
+      # @return [Hash] Aggregated metrics
+      def self.aggregate_period_stats(scope)
+        total, success, errors, timeouts, cost, avg_dur, tokens = scope.pick(
+          Arel.sql("COUNT(*)"),
+          Arel.sql("SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END)"),
+          Arel.sql("SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END)"),
+          Arel.sql("SUM(CASE WHEN status = 'timeout' THEN 1 ELSE 0 END)"),
+          Arel.sql("COALESCE(SUM(total_cost), 0)"),
+          Arel.sql("AVG(duration_ms)"),
+          Arel.sql("COALESCE(SUM(total_tokens), 0)")
+        )
+
+        total = total.to_i
+        success = success.to_i
+
+        {
+          total: total,
+          success: success,
+          errors: errors.to_i,
+          timeouts: timeouts.to_i,
+          cost: cost.to_f,
+          avg_duration_ms: avg_dur.to_i,
+          tokens: tokens.to_i,
+          success_rate: (total > 0) ? (success.to_f / total * 100).round(1) : 0.0
+        }
+      end
+      private_class_method :aggregate_period_stats
+
       private
 
       # Calculates and sets total_tokens from input and output
@@ -420,7 +441,8 @@ module RubyLLM
         return nil unless lookup_model_id
 
         RubyLLM::Models.find(lookup_model_id)
-      rescue
+      rescue => e
+        Rails.logger.debug("[RubyLLM::Agents] Model lookup failed for #{lookup_model_id}: #{e.message}") if defined?(Rails) && Rails.logger
         nil
       end
     end

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

@@ -13,6 +13,8 @@ module RubyLLM
       self.table_name = "ruby_llm_agents_execution_details"
 
       belongs_to :execution, class_name: "RubyLLM::Agents::Execution"
+
+      validates :execution_id, presence: true
     end
   end
 end

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

@@ -53,6 +53,45 @@ module RubyLLM
       scope :linked, -> { where.not(tenant_record_type: nil) }
       scope :unlinked, -> { where(tenant_record_type: nil) }
 
+      # Returns top tenants by monthly spend for dashboard display
+      #
+      # Ensures counter resets are current before returning data.
+      #
+      # @param limit [Integer] Max tenants to return
+      # @return [Array<Hash>, nil] Tenant spend data or nil if none
+      def self.top_by_spend(limit: 5)
+        return nil unless table_exists?
+
+        tenants = active
+          .where("monthly_cost_spent > 0 OR monthly_executions_count > 0")
+          .order(monthly_cost_spent: :desc)
+          .limit(limit)
+
+        return nil if tenants.empty?
+
+        tenants.map do |tenant|
+          tenant.ensure_daily_reset!
+          tenant.ensure_monthly_reset!
+
+          monthly_limit = tenant.effective_monthly_limit
+          daily_limit = tenant.effective_daily_limit
+
+          {
+            id: tenant.id,
+            tenant_id: tenant.tenant_id,
+            name: tenant.display_name,
+            enforcement: tenant.effective_enforcement,
+            monthly_spend: tenant.monthly_cost_spent,
+            monthly_limit: monthly_limit,
+            monthly_percentage: (monthly_limit.to_f > 0) ? (tenant.monthly_cost_spent / monthly_limit * 100).round(1) : 0,
+            daily_spend: tenant.daily_cost_spent,
+            daily_limit: daily_limit,
+            daily_percentage: (daily_limit.to_f > 0) ? (tenant.daily_cost_spent / daily_limit * 100).round(1) : 0,
+            monthly_executions: tenant.monthly_executions_count
+          }
+        end
+      end
+
       # Find tenant for given record or ID
       #
       # Supports multiple lookup strategies:

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

@@ -54,8 +54,106 @@ module RubyLLM
           end
         end
 
+        # Extracts full configuration for an agent class
+        #
+        # Combines base config with type-specific config for display.
+        #
+        # @param agent_class [Class] The agent class
+        # @return [Hash] Configuration hash
+        def config_for(agent_class)
+          return {} unless agent_class
+
+          base = {
+            model: safe_call(agent_class, :model),
+            version: safe_call(agent_class, :version),
+            description: safe_call(agent_class, :description)
+          }
+
+          type = detect_agent_type(agent_class)
+          base.merge(type_config_for(agent_class, type))
+        end
+
         private
 
+        # Extracts type-specific configuration
+        #
+        # @param agent_class [Class] The agent class
+        # @param type [String] The detected agent type
+        # @return [Hash] Type-specific config
+        def type_config_for(agent_class, type)
+          case type
+          when "embedder"
+            {
+              dimensions: safe_call(agent_class, :dimensions),
+              batch_size: safe_call(agent_class, :batch_size),
+              cache_enabled: safe_call(agent_class, :cache_enabled?) || false,
+              cache_ttl: safe_call(agent_class, :cache_ttl)
+            }
+          when "speaker"
+            {
+              provider: safe_call(agent_class, :provider),
+              voice: safe_call(agent_class, :voice),
+              voice_id: safe_call(agent_class, :voice_id),
+              speed: safe_call(agent_class, :speed),
+              output_format: safe_call(agent_class, :output_format),
+              streaming: safe_call(agent_class, :streaming?),
+              ssml_enabled: safe_call(agent_class, :ssml_enabled?),
+              cache_enabled: safe_call(agent_class, :cache_enabled?) || false,
+              cache_ttl: safe_call(agent_class, :cache_ttl)
+            }
+          when "transcriber"
+            {
+              language: safe_call(agent_class, :language),
+              output_format: safe_call(agent_class, :output_format),
+              include_timestamps: safe_call(agent_class, :include_timestamps),
+              cache_enabled: safe_call(agent_class, :cache_enabled?) || false,
+              cache_ttl: safe_call(agent_class, :cache_ttl),
+              fallback_models: safe_call(agent_class, :fallback_models)
+            }
+          when "image_generator"
+            {
+              size: safe_call(agent_class, :size),
+              quality: safe_call(agent_class, :quality),
+              style: safe_call(agent_class, :style),
+              content_policy: safe_call(agent_class, :content_policy),
+              template: safe_call(agent_class, :template_string),
+              negative_prompt: safe_call(agent_class, :negative_prompt),
+              seed: safe_call(agent_class, :seed),
+              guidance_scale: safe_call(agent_class, :guidance_scale),
+              steps: safe_call(agent_class, :steps),
+              cache_enabled: safe_call(agent_class, :cache_enabled?) || false,
+              cache_ttl: safe_call(agent_class, :cache_ttl)
+            }
+          when "router"
+            routes = safe_call(agent_class, :routes) || {}
+            {
+              temperature: safe_call(agent_class, :temperature),
+              timeout: safe_call(agent_class, :timeout),
+              cache_enabled: safe_call(agent_class, :cache_enabled?) || false,
+              cache_ttl: safe_call(agent_class, :cache_ttl),
+              default_route: safe_call(agent_class, :default_route_name),
+              routes: routes.transform_values { |v| v[:description] },
+              route_count: routes.size,
+              retries: safe_call(agent_class, :retries),
+              fallback_models: safe_call(agent_class, :fallback_models),
+              total_timeout: safe_call(agent_class, :total_timeout),
+              circuit_breaker: safe_call(agent_class, :circuit_breaker_config)
+            }
+          else # base agent
+            {
+              temperature: safe_call(agent_class, :temperature),
+              timeout: safe_call(agent_class, :timeout),
+              cache_enabled: safe_call(agent_class, :cache_enabled?) || false,
+              cache_ttl: safe_call(agent_class, :cache_ttl),
+              params: safe_call(agent_class, :params) || {},
+              retries: safe_call(agent_class, :retries),
+              fallback_models: safe_call(agent_class, :fallback_models),
+              total_timeout: safe_call(agent_class, :total_timeout),
+              circuit_breaker: safe_call(agent_class, :circuit_breaker_config)
+            }
+          end
+        end
+
         # Finds agent classes from the file system
         #
         # @return [Array<String>] Agent class names

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

@@ -295,7 +295,8 @@
           <% nav_items = [
             [ruby_llm_agents.root_path, "dashboard"],
             [ruby_llm_agents.agents_path, "agents"],
-            [ruby_llm_agents.executions_path, "executions"]
+            [ruby_llm_agents.executions_path, "executions"],
+            [ruby_llm_agents.requests_path, "requests"]
           ]
           nav_items << [ruby_llm_agents.tenants_path, "tenants"] if tenant_filter_enabled?
           nav_items.each do |path, label| %>
@@ -345,7 +346,8 @@
           <% mobile_nav_items = [
             [ruby_llm_agents.root_path, "dashboard"],
             [ruby_llm_agents.agents_path, "agents"],
-            [ruby_llm_agents.executions_path, "executions"]
+            [ruby_llm_agents.executions_path, "executions"],
+            [ruby_llm_agents.requests_path, "requests"]
           ]
           mobile_nav_items << [ruby_llm_agents.tenants_path, "tenants"] if tenant_filter_enabled?
           mobile_nav_items.each do |path, label| %>

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

@@ -2,26 +2,12 @@
 <% show_tenant_column = tenant_filter_enabled? && current_tenant_id.blank? %>
 
 <%
-  # Inline sort helper
+  # Sort params for the sort_header_link helper
   sort_column = @sort_params[:column]
   sort_direction = @sort_params[:direction]
 
-  sort_link = ->(column, label, align: "left", extra_class: "") {
-    is_active = column == sort_column
-    next_dir = is_active && sort_direction == "asc" ? "desc" : "asc"
-    url = url_for(request.query_parameters.merge(sort: column, direction: next_dir, page: 1))
-
-    arrow = if is_active && sort_direction == "asc"
-              raw('<svg class="w-2.5 h-2.5 inline" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 15l7-7 7 7"/></svg>')
-            elsif is_active
-              raw('<svg class="w-2.5 h-2.5 inline" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/></svg>')
-            else
-              ""
-            end
-
-    active_class = is_active ? "text-gray-700 dark:text-gray-300" : ""
-
-    raw(%(<a href="#{url}" class="group inline-flex items-center gap-0.5 hover:text-gray-700 dark:hover:text-gray-300 #{active_class} #{extra_class}"><span>#{label}</span><span class="#{is_active ? 'opacity-100' : 'opacity-0 group-hover:opacity-50'} transition-opacity">#{arrow}</span></a>))
+  sort_link = ->(column, label, extra_class: "") {
+    sort_header_link(column, label, current_column: sort_column, current_direction: sort_direction, extra_class: extra_class)
   }
 %>
 

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

@@ -0,0 +1,153 @@
+<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>
+</div>
+
+<%
+  sort_column = @sort_column
+  sort_direction = @sort_direction
+
+  sort_link = ->(column, label, extra_class: "") {
+    is_active = column == sort_column
+    next_dir = is_active && sort_direction == "asc" ? "desc" : "asc"
+    url = url_for(request.query_parameters.merge(sort: column, direction: next_dir, page: 1))
+
+    arrow = if is_active && sort_direction == "asc"
+              raw('<svg class="w-2.5 h-2.5 inline" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 15l7-7 7 7"/></svg>')
+            elsif is_active
+              raw('<svg class="w-2.5 h-2.5 inline" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/></svg>')
+            else
+              ""
+            end
+
+    active_class = is_active ? "text-gray-700 dark:text-gray-300" : ""
+    raw(%(<a href="#{url}" class="group inline-flex items-center gap-0.5 hover:text-gray-700 dark:hover:text-gray-300 #{active_class} #{extra_class}"><span>#{label}</span><span class="#{is_active ? 'opacity-100' : 'opacity-0 group-hover:opacity-50'} transition-opacity">#{arrow}</span></a>))
+  }
+%>
+
+<% if @requests.empty? %>
+  <div class="font-mono text-xs text-gray-400 dark:text-gray-600 py-8 text-center">
+    No tracked requests found. Use <code class="bg-gray-100 dark:bg-gray-800 px-1.5 py-0.5 rounded">RubyLLM::Agents.track { ... }</code> to start tracking.
+  </div>
+<% else %>
+  <!-- Column headers -->
+  <div class="flex items-center gap-3 px-2 -mx-2 font-mono text-[10px] text-gray-400 dark:text-gray-600 uppercase tracking-wider mb-1">
+    <span class="w-36 flex-shrink-0">request_id</span>
+    <span class="flex-1 min-w-0">agents</span>
+    <span class="w-12 flex-shrink-0 text-right"><%= sort_link.call("call_count", "calls", extra_class: "justify-end w-full") %></span>
+    <span class="w-14 flex-shrink-0 text-right hidden sm:block">status</span>
+    <span class="w-16 flex-shrink-0 text-right hidden md:block"><%= sort_link.call("total_duration_ms", "duration", extra_class: "justify-end w-full") %></span>
+    <span class="w-16 flex-shrink-0 text-right hidden md:block"><%= sort_link.call("total_tokens", "tokens", extra_class: "justify-end w-full") %></span>
+    <span class="w-16 flex-shrink-0 text-right"><%= sort_link.call("total_cost", "cost", extra_class: "justify-end w-full") %></span>
+    <span class="w-24 flex-shrink-0 text-right"><%= sort_link.call("latest_created_at", "time", extra_class: "justify-end w-full") %></span>
+  </div>
+
+  <!-- Rows -->
+  <div class="font-mono text-xs space-y-px">
+    <% @requests.each do |req| %>
+      <%
+        statuses = (req.statuses_list || "").split(",")
+        has_errors = statuses.include?("error") || statuses.include?("timeout")
+        all_success = statuses == ["success"]
+        status_class = if has_errors
+          "badge-error"
+        elsif all_success
+          "badge-success"
+        else
+          "badge-running"
+        end
+        status_label = if has_errors
+          "errors"
+        elsif all_success
+          "ok"
+        else
+          "mixed"
+        end
+        agent_names = (req.agent_types_list || "").split(",").map { |a| a.gsub(/Agent$/, "") }
+      %>
+      <div 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"
+           onclick="window.location='<%= ruby_llm_agents.request_path(req.request_id) %>'">
+        <span class="w-36 flex-shrink-0 truncate text-gray-900 dark:text-gray-200" title="<%= req.request_id %>">
+          <%= truncate(req.request_id, length: 20) %>
+        </span>
+        <span class="flex-1 min-w-0 truncate text-gray-400 dark:text-gray-600">
+          <%= agent_names.first(3).join(", ") %><%= agent_names.size > 3 ? " +#{agent_names.size - 3}" : "" %>
+        </span>
+        <span class="w-12 flex-shrink-0 text-right text-gray-500 dark:text-gray-400"><%= req.call_count %></span>
+        <span class="w-14 flex-shrink-0 text-right hidden sm:block">
+          <span class="badge badge-sm <%= status_class %>"><%= status_label %></span>
+        </span>
+        <span class="w-16 flex-shrink-0 text-right text-gray-500 dark:text-gray-400 hidden md:inline">
+          <%= req.total_duration_ms ? format_duration_ms(req.total_duration_ms.to_i) : "—" %>
+        </span>
+        <span class="w-16 flex-shrink-0 text-right text-gray-500 dark:text-gray-400 hidden md:inline"><%= number_with_delimiter(req.total_tokens || 0) %></span>
+        <span class="w-16 flex-shrink-0 text-right text-gray-500 dark:text-gray-400">$<%= number_with_precision(req.total_cost || 0, precision: 4) %></span>
+        <span class="w-24 flex-shrink-0 text-gray-400 dark:text-gray-600 text-right whitespace-nowrap">
+          <% if req.respond_to?(:latest_created_at) && req.latest_created_at %>
+            <%= time_ago_in_words(req.latest_created_at) %>
+          <% else %>
+            —
+          <% end %>
+        </span>
+      </div>
+    <% 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 %>
+<% end %>