ruby_llm-agents 3.7.2 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 891034cc430fa52a5b9d1b07bd9cf06558414b91396f4a1521ebd0f8618f2a68
-  data.tar.gz: fc6775ed017277076bec9c0931cfe4c34d4ef1023815f4898458f40e55b61855
+  metadata.gz: 6925b14509a50c3bbf5efb8d0e37f5a38b4d2f52f13f3c7ecd7af588f832c5c1
+  data.tar.gz: 4332d03ebaf4bd94f3e314656e7f6755475c5ad45661a8c1e76e6e324d37ec2e
 SHA512:
-  metadata.gz: 9de47e331e3f0b48465fa12c9f91f79045dfec64d76f242308184a36c41a67be7d324d9b358c96450cde053dbb8f69fe326a1d3a6078a3ea93136b8c327edc30
-  data.tar.gz: d7ba9f35cf90656e7618189141d7291d704dd7199c54ced508d9da1cb72aa417f1988cd15e884cd42f2ae235e3149c2c31ca0d4d3567db9e04132d890a11e517
+  metadata.gz: e12ea68a14b7c9ec683ae7b07a14d9d422922fc8e5233d7296fd42bc6100097bb929da87b6c52fe55929779a17c04e59253fa490c40147558392a32a79023fa6
+  data.tar.gz: 9d0d5d249ee0bb6bac741d5c1087ade27ba0a6d032184bb01e1ecfc0d43f79453fbd12cd22e9e4f3eeca7b457bfb242ebca7ebc4e010f44387b9ee8a13bf0865

data/README.md

@@ -206,7 +206,7 @@ puts run.summary
 
 ## Quick Start
 
-### Installation
+### 1. Install
 
 ```ruby
 # Gemfile
@@ -219,29 +219,49 @@ rails generate ruby_llm_agents:install
 rails db:migrate
 ```
 
-### Configure API Keys
+### 2. Set one API key
 
-Configure all provider API keys in one place (v2.1+):
+Uncomment one line in `config/initializers/ruby_llm_agents.rb`:
 
 ```ruby
-# config/initializers/ruby_llm_agents.rb
 RubyLLM::Agents.configure do |config|
   config.openai_api_key = ENV["OPENAI_API_KEY"]
-  config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
-  config.gemini_api_key = ENV["GOOGLE_API_KEY"]
 end
 ```
 
-Or use environment variables directly (auto-detected by RubyLLM):
+Then set the environment variable (e.g., in `.env` or Rails credentials).
+
+<details>
+<summary>Other providers</summary>
 
+```ruby
+config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+config.gemini_api_key    = ENV["GOOGLE_API_KEY"]
+config.deepseek_api_key  = ENV["DEEPSEEK_API_KEY"]
+# ... see initializer for full list
+```
+
+Or use environment variables directly (auto-detected by RubyLLM):
 ```bash
-# .env
 OPENAI_API_KEY=sk-...
 ANTHROPIC_API_KEY=sk-ant-...
-GOOGLE_API_KEY=...
+```
+</details>
+
+### 3. Verify setup
+
+```bash
+rails ruby_llm_agents:doctor
+```
+
+### 4. Try it
+
+```bash
+rails generate ruby_llm_agents:demo
+bin/rails runner bin/smoke_test_agent
 ```
 
-### Generate an Agent
+Or generate a custom agent:
 
 ```bash
 rails generate ruby_llm_agents:agent SearchIntent query:required

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

@@ -100,11 +100,12 @@ module RubyLLM
       #
       # @return [void]
       def load_agent_stats
-        @stats = Execution.stats_for(@agent_type, period: :all_time)
-        @stats_today = Execution.stats_for(@agent_type, period: :today)
+        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 = Execution.by_agent(@agent_type)
+        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
@@ -118,9 +119,10 @@ module RubyLLM
       # @return [void]
       def load_filter_options
         # Single query to get all filter options (fixes N+1)
-        filter_data = Execution.by_agent(@agent_type)
+        base = tenant_scoped_executions.by_agent(@agent_type)
+        filter_data = base
           .where.not(model_id: nil)
-          .or(Execution.by_agent(@agent_type).where.not(temperature: nil))
+          .or(base.where.not(temperature: nil))
           .pluck(:model_id, :temperature)
 
         @models = filter_data.map(&:first).compact.uniq.sort
@@ -152,7 +154,7 @@ module RubyLLM
       #
       # @return [ActiveRecord::Relation] Filtered execution scope
       def build_filtered_scope
-        scope = Execution.by_agent(@agent_type)
+        scope = tenant_scoped_executions.by_agent(@agent_type)
 
         # Apply status filter with validation
         statuses = parse_array_param(:statuses)
@@ -177,9 +179,10 @@ module RubyLLM
       #
       # @return [void]
       def load_chart_data
-        @trend_data = Execution.trend_analysis(agent_type: @agent_type, days: 30)
-        @status_distribution = Execution.by_agent(@agent_type).group(:status).count
-        @finish_reason_distribution = Execution.by_agent(@agent_type).finish_reason_distribution
+        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
       end
 
       # Loads the current agent class configuration
@@ -189,140 +192,10 @@ module RubyLLM
       # Detects agent type and loads appropriate config.
       #
       # @return [void]
+      # Loads agent configuration using AgentRegistry
       def load_agent_config
         @agent_type_kind = AgentRegistry.send(:detect_agent_type, @agent_class)
-
-        # Common config for all types
-        @config = {
-          model: safe_config_call(:model),
-          description: safe_config_call(:description)
-        }
-
-        # Type-specific config
-        case @agent_type_kind
-        when "embedder"
-          load_embedder_config
-        when "speaker"
-          load_speaker_config
-        when "transcriber"
-          load_transcriber_config
-        when "image_generator"
-          load_image_generator_config
-        when "router"
-          load_router_config
-        else
-          load_base_agent_config
-        end
-      end
-
-      # Loads configuration specific to Base agents
-      #
-      # @return [void]
-      def load_base_agent_config
-        @config.merge!(
-          temperature: safe_config_call(:temperature),
-          timeout: safe_config_call(:timeout),
-          cache_enabled: safe_config_call(:cache_enabled?) || false,
-          cache_ttl: safe_config_call(:cache_ttl),
-          params: safe_config_call(:params) || {},
-          retries: safe_config_call(:retries),
-          fallback_models: safe_config_call(:fallback_models),
-          total_timeout: safe_config_call(:total_timeout),
-          circuit_breaker: safe_config_call(:circuit_breaker_config)
-        )
-      end
-
-      # Loads configuration specific to Embedders
-      #
-      # @return [void]
-      def load_embedder_config
-        @config.merge!(
-          dimensions: safe_config_call(:dimensions),
-          batch_size: safe_config_call(:batch_size),
-          cache_enabled: safe_config_call(:cache_enabled?) || false,
-          cache_ttl: safe_config_call(:cache_ttl)
-        )
-      end
-
-      # Loads configuration specific to Speakers
-      #
-      # @return [void]
-      def load_speaker_config
-        @config.merge!(
-          provider: safe_config_call(:provider),
-          voice: safe_config_call(:voice),
-          voice_id: safe_config_call(:voice_id),
-          speed: safe_config_call(:speed),
-          output_format: safe_config_call(:output_format),
-          streaming: safe_config_call(:streaming?),
-          ssml_enabled: safe_config_call(:ssml_enabled?),
-          cache_enabled: safe_config_call(:cache_enabled?) || false,
-          cache_ttl: safe_config_call(:cache_ttl)
-        )
-      end
-
-      # Loads configuration specific to Transcribers
-      #
-      # @return [void]
-      def load_transcriber_config
-        @config.merge!(
-          language: safe_config_call(:language),
-          output_format: safe_config_call(:output_format),
-          include_timestamps: safe_config_call(:include_timestamps),
-          cache_enabled: safe_config_call(:cache_enabled?) || false,
-          cache_ttl: safe_config_call(:cache_ttl),
-          fallback_models: safe_config_call(:fallback_models)
-        )
-      end
-
-      # Loads configuration specific to ImageGenerators
-      #
-      # @return [void]
-      def load_image_generator_config
-        @config.merge!(
-          size: safe_config_call(:size),
-          quality: safe_config_call(:quality),
-          style: safe_config_call(:style),
-          content_policy: safe_config_call(:content_policy),
-          template: safe_config_call(:template_string),
-          negative_prompt: safe_config_call(:negative_prompt),
-          seed: safe_config_call(:seed),
-          guidance_scale: safe_config_call(:guidance_scale),
-          steps: safe_config_call(:steps),
-          cache_enabled: safe_config_call(:cache_enabled?) || false,
-          cache_ttl: safe_config_call(:cache_ttl)
-        )
-      end
-
-      # Loads configuration specific to Router agents
-      #
-      # @return [void]
-      def load_router_config
-        routes = safe_config_call(:routes) || {}
-        @config.merge!(
-          temperature: safe_config_call(:temperature),
-          timeout: safe_config_call(:timeout),
-          cache_enabled: safe_config_call(:cache_enabled?) || false,
-          cache_ttl: safe_config_call(:cache_ttl),
-          default_route: safe_config_call(:default_route_name),
-          routes: routes.transform_values { |v| v[:description] },
-          route_count: routes.size,
-          retries: safe_config_call(:retries),
-          fallback_models: safe_config_call(:fallback_models),
-          total_timeout: safe_config_call(:total_timeout),
-          circuit_breaker: safe_config_call(:circuit_breaker_config)
-        )
-      end
-
-      # Safely calls a method on the agent class, returning nil on error
-      #
-      # @param method [Symbol] The method to call
-      # @return [Object, nil] The result or nil if error
-      def safe_config_call(method)
-        return nil unless @agent_class&.respond_to?(method)
-        @agent_class.public_send(method)
-      rescue
-        nil
+        @config = AgentRegistry.config_for(@agent_class)
       end
 
       # Loads circuit breaker status for the agent's models

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

@@ -24,7 +24,7 @@ module RubyLLM
         base_scope = tenant_scoped_executions
         @now_strip = build_now_strip(base_scope)
         @critical_alerts = load_critical_alerts(base_scope)
-        @recent_executions = base_scope.recent(10)
+        @recent_executions = base_scope.includes(:detail).recent(10)
         @agent_stats = build_agent_comparison(base_scope)
         @top_errors = build_top_errors(base_scope)
         @tenant_budget = load_tenant_budget(base_scope)
@@ -194,100 +194,14 @@ module RubyLLM
         @agent_stats
       end
 
-      # Builds per-model statistics for model comparison and cost breakdown
-      #
-      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
-      # @return [Array<Hash>] Array of model stats sorted by total cost descending
+      # Delegates to Execution.model_stats with time scoping
       def build_model_stats(base_scope = Execution)
-        scope = time_scoped(base_scope).where.not(model_id: nil)
-
-        # Batch fetch stats grouped by model
-        counts = scope.group(:model_id).count
-        costs = scope.group(:model_id).sum(:total_cost)
-        tokens = scope.group(:model_id).sum(:total_tokens)
-        durations = scope.group(:model_id).average(:duration_ms)
-        success_counts = scope.successful.group(:model_id).count
-
-        total_cost = costs.values.sum
-
-        model_ids = counts.keys
-        model_ids.map do |model_id|
-          count = counts[model_id] || 0
-          model_cost = costs[model_id] || 0
-          model_tokens = tokens[model_id] || 0
-          successful = success_counts[model_id] || 0
-
-          {
-            model_id: model_id,
-            executions: count,
-            total_cost: model_cost,
-            total_tokens: model_tokens,
-            avg_duration_ms: durations[model_id]&.round || 0,
-            success_rate: (count > 0) ? (successful.to_f / count * 100).round(1) : 0,
-            cost_per_1k_tokens: (model_tokens > 0) ? (model_cost / model_tokens * 1000).round(4) : 0,
-            cost_percentage: (total_cost > 0) ? (model_cost / total_cost * 100).round(1) : 0
-          }
-        end.sort_by { |m| -(m[:total_cost] || 0) }
+        Execution.model_stats(scope: time_scoped(base_scope))
       end
 
-      # Builds top errors list
-      #
-      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
-      # @return [Array<Hash>] Top 5 error classes with counts
+      # Delegates to Execution.top_errors with time scoping
       def build_top_errors(base_scope = Execution)
-        scope = time_scoped(base_scope).where(status: "error")
-        total_errors = scope.count
-
-        scope.group(:error_class)
-          .select("error_class, COUNT(*) as count, MAX(created_at) as last_seen")
-          .order("count DESC")
-          .limit(5)
-          .map do |row|
-            {
-              error_class: row.error_class || "Unknown Error",
-              count: row.count,
-              percentage: (total_errors > 0) ? (row.count.to_f / total_errors * 100).round(1) : 0,
-              last_seen: row.last_seen
-            }
-        end
-      end
-
-      # Fetches cached daily statistics for the dashboard
-      #
-      # Results are cached for 1 minute to reduce database load while
-      # keeping the dashboard reasonably up-to-date.
-      #
-      # @return [Hash] Daily statistics
-      # @option return [Integer] :total_executions Total execution count today
-      # @option return [Integer] :successful Successful execution count
-      # @option return [Integer] :failed Failed execution count
-      # @option return [Float] :total_cost Combined cost of all executions
-      # @option return [Integer] :total_tokens Combined token usage
-      # @option return [Integer] :avg_duration_ms Average execution duration
-      # @option return [Float] :success_rate Percentage of successful executions
-      def daily_stats
-        Rails.cache.fetch("ruby_llm_agents/daily_stats/#{Date.current}", expires_in: 1.minute) do
-          scope = Execution.today
-          {
-            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,
-            success_rate: calculate_success_rate(scope)
-          }
-        end
-      end
-
-      # Calculates the success rate percentage for a scope
-      #
-      # @param scope [ActiveRecord::Relation] The execution scope to calculate from
-      # @return [Float] Success rate as a percentage (0.0-100.0)
-      def calculate_success_rate(scope)
-        total = scope.count
-        return 0.0 if total.zero?
-        (scope.successful.count.to_f / total * 100).round(1)
+        Execution.top_errors(scope: time_scoped(base_scope))
       end
 
       # Loads budget status for display on dashboard
@@ -304,7 +218,7 @@ module RubyLLM
         open_breakers = []
 
         # Get all agents from execution history
-        agent_types = Execution.distinct.pluck(:agent_type)
+        agent_types = tenant_scoped_executions.distinct.pluck(:agent_type)
 
         agent_types.each do |agent_type|
           # Get the agent class if available
@@ -435,87 +349,19 @@ module RubyLLM
         alerts.take(3)
       end
 
-      # Builds cache savings statistics for the dashboard
-      #
-      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
-      # @return [Hash] Cache savings data with count, estimated savings, and hit rate
+      # Delegates to Execution.cache_savings with time scoping
       def build_cache_savings(base_scope)
-        scope = time_scoped(base_scope)
-        total_count = scope.count
-        return {count: 0, estimated_savings: 0, hit_rate: 0, total_executions: 0} if total_count.zero?
-
-        cached_scope = scope.cached
-        cache_count = cached_scope.count
-        estimated_savings = cached_scope.sum(:total_cost)
-
-        {
-          count: cache_count,
-          estimated_savings: estimated_savings,
-          hit_rate: (cache_count.to_f / total_count * 100).round(1),
-          total_executions: total_count
-        }
+        Execution.cache_savings(scope: time_scoped(base_scope))
       end
 
-      # Builds top tenants list for the dashboard overview
-      #
-      # @return [Array<Hash>, nil] Top 5 tenants by monthly spend, or nil if none
+      # Delegates to Tenant.top_by_spend
       def build_top_tenants
-        return nil unless Tenant.table_exists?
-
-        tenants = Tenant.active
-          .where("monthly_cost_spent > 0 OR monthly_executions_count > 0")
-          .order(monthly_cost_spent: :desc)
-          .limit(5)
-
-        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
+        Tenant.top_by_spend(limit: 5)
       end
 
-      # Batch fetches execution stats for all agents in a time period
-      #
-      # @param scope [ActiveRecord::Relation] Base scope with time filter
-      # @return [Hash<String, Hash>] Agent type => stats hash
+      # Delegates to Execution.batch_agent_stats with pre-filtered scope
       def batch_fetch_agent_stats(scope)
-        counts = scope.group(:agent_type).count
-        costs = scope.group(:agent_type).sum(:total_cost)
-        success_counts = scope.successful.group(:agent_type).count
-        durations = scope.group(:agent_type).average(:duration_ms)
-
-        agent_types = (counts.keys + costs.keys).uniq
-        agent_types.each_with_object({}) do |agent_type, hash|
-          count = counts[agent_type] || 0
-          total_cost = costs[agent_type] || 0
-          successful = success_counts[agent_type] || 0
-
-          hash[agent_type] = {
-            count: count,
-            total_cost: total_cost,
-            avg_cost: (count > 0) ? (total_cost / count).round(6) : 0,
-            avg_duration_ms: durations[agent_type]&.round || 0,
-            success_rate: (count > 0) ? (successful.to_f / count * 100).round(1) : 0
-          }
-        end
+        Execution.batch_agent_stats(scope: scope)
       end
     end
   end

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

@@ -39,7 +39,7 @@ module RubyLLM
       #
       # @return [void]
       def show
-        @execution = Execution.find(params[:id])
+        @execution = tenant_scoped_executions.includes(:detail, :child_executions).find(params[:id])
       end
 
       # Handles filter search requests via Turbo Stream

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Controller for browsing tracked request groups
+    #
+    # Provides listing and detail views for executions grouped by
+    # request_id, as set by RubyLLM::Agents.track blocks.
+    #
+    # @api private
+    class RequestsController < ApplicationController
+      include Paginatable
+
+      # Lists all tracked requests with aggregated stats
+      #
+      # @return [void]
+      def index
+        @sort_column = sanitize_sort_column(params[:sort])
+        @sort_direction = (params[:direction] == "asc") ? "asc" : "desc"
+
+        scope = Execution
+          .where.not(request_id: [nil, ""])
+          .select(
+            "request_id",
+            "COUNT(*) AS call_count",
+            "SUM(total_cost) AS total_cost",
+            "SUM(total_tokens) AS total_tokens",
+            "MIN(started_at) AS started_at",
+            "MAX(completed_at) AS completed_at",
+            "SUM(duration_ms) AS total_duration_ms",
+            "GROUP_CONCAT(DISTINCT agent_type) AS agent_types_list",
+            "GROUP_CONCAT(DISTINCT status) AS statuses_list",
+            "MAX(created_at) AS latest_created_at"
+          )
+          .group(:request_id)
+
+        # Apply time filter
+        days = params[:days].to_i
+        scope = scope.where("created_at >= ?", days.days.ago) if days > 0
+
+        result = paginate_requests(scope)
+        @requests = result[:records]
+        @pagination = result[:pagination]
+
+        # Stats
+        total_scope = Execution.where.not(request_id: [nil, ""])
+        @stats = {
+          total_requests: total_scope.distinct.count(:request_id),
+          total_cost: total_scope.sum(:total_cost) || 0
+        }
+      end
+
+      # Shows a single tracked request with all its executions
+      #
+      # @return [void]
+      def show
+        @request_id = params[:id]
+        @executions = Execution
+          .where(request_id: @request_id)
+          .order(started_at: :asc)
+
+        if @executions.empty?
+          redirect_to ruby_llm_agents.requests_path,
+            alert: "Request not found: #{@request_id}"
+          return
+        end
+
+        @summary = {
+          call_count: @executions.count,
+          total_cost: @executions.sum(:total_cost) || 0,
+          total_tokens: @executions.sum(:total_tokens) || 0,
+          started_at: @executions.minimum(:started_at),
+          completed_at: @executions.maximum(:completed_at),
+          agent_types: @executions.distinct.pluck(:agent_type),
+          models_used: @executions.distinct.pluck(:model_id),
+          all_successful: @executions.where.not(status: "success").count.zero?,
+          error_count: @executions.where(status: "error").count
+        }
+
+        if @summary[:started_at] && @summary[:completed_at]
+          @summary[:duration_ms] = ((@summary[:completed_at] - @summary[:started_at]) * 1000).to_i
+        end
+      end
+
+      private
+
+      ALLOWED_SORT_COLUMNS = %w[latest_created_at call_count total_cost total_tokens total_duration_ms].freeze
+
+      def sanitize_sort_column(column)
+        ALLOWED_SORT_COLUMNS.include?(column) ? column : "latest_created_at"
+      end
+
+      def paginate_requests(scope)
+        page = [(params[:page] || 1).to_i, 1].max
+        per_page = RubyLLM::Agents.configuration.per_page
+
+        total_count = Execution
+          .where.not(request_id: [nil, ""])
+          .distinct
+          .count(:request_id)
+
+        sorted = scope.order("#{@sort_column} #{@sort_direction.upcase}")
+        offset = (page - 1) * per_page
+
+        {
+          records: sorted.offset(offset).limit(per_page),
+          pagination: {
+            current_page: page,
+            per_page: per_page,
+            total_count: total_count,
+            total_pages: (total_count.to_f / per_page).ceil
+          }
+        }
+      end
+    end
+  end
+end

data/app/helpers/ruby_llm/agents/application_helper.rb

@@ -120,6 +120,44 @@ module RubyLLM
         end
       end
 
+      # Renders a sortable column header link with arrow indicator
+      #
+      # Replaces inline `raw()` calls in views with safe content_tag usage.
+      #
+      # @param column [String] The sort column name
+      # @param label [String] Display label for the header
+      # @param current_column [String] Currently active sort column
+      # @param current_direction [String] Current sort direction ("asc"/"desc")
+      # @param extra_class [String] Additional CSS classes
+      # @return [ActiveSupport::SafeBuffer] HTML link element
+      def sort_header_link(column, label, current_column:, current_direction:, extra_class: "")
+        is_active = column == current_column
+        next_dir = (is_active && current_direction == "asc") ? "desc" : "asc"
+        url = url_for(request.query_parameters.merge(sort: column, direction: next_dir, page: 1))
+
+        arrow = if is_active && current_direction == "asc"
+          content_tag(:svg, class: "w-2.5 h-2.5 inline", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24") do
+            content_tag(:path, nil, "stroke-linecap": "round", "stroke-linejoin": "round", "stroke-width": "2", d: "M5 15l7-7 7 7")
+          end
+        elsif is_active
+          content_tag(:svg, class: "w-2.5 h-2.5 inline", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24") do
+            content_tag(:path, nil, "stroke-linecap": "round", "stroke-linejoin": "round", "stroke-width": "2", d: "M19 9l-7 7-7-7")
+          end
+        else
+          "".html_safe
+        end
+
+        active_class = is_active ? "text-gray-700 dark:text-gray-300" : ""
+        opacity_class = is_active ? "opacity-100" : "opacity-0 group-hover:opacity-50"
+
+        link_to url, class: "group inline-flex items-center gap-0.5 hover:text-gray-700 dark:hover:text-gray-300 #{active_class} #{extra_class}" do
+          safe_join([
+            content_tag(:span, label),
+            content_tag(:span, arrow, class: "#{opacity_class} transition-opacity")
+          ])
+        end
+      end
+
       # Syntax-highlights a Ruby object as pretty-printed JSON
       #
       # Converts the object to JSON and applies color highlighting