ruby_llm-agents 3.7.2 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 891034cc430fa52a5b9d1b07bd9cf06558414b91396f4a1521ebd0f8618f2a68
-  data.tar.gz: fc6775ed017277076bec9c0931cfe4c34d4ef1023815f4898458f40e55b61855
+  metadata.gz: e2d24a8046e58bdadf37d70ddb1effb038f69b1fa01c4dd7f9e08bf819527d94
+  data.tar.gz: 0f620acc86ebe001c151c6a95ee784463bb1e10eb66532e7f6d2684ca2021f06
 SHA512:
-  metadata.gz: 9de47e331e3f0b48465fa12c9f91f79045dfec64d76f242308184a36c41a67be7d324d9b358c96450cde053dbb8f69fe326a1d3a6078a3ea93136b8c327edc30
-  data.tar.gz: d7ba9f35cf90656e7618189141d7291d704dd7199c54ced508d9da1cb72aa417f1988cd15e884cd42f2ae235e3149c2c31ca0d4d3567db9e04132d890a11e517
+  metadata.gz: 9bd06ce2399f86359e00a115d269af22d3f73a0ad8a1bc0d21e315c4a41b0a023bd59b9b9504ac3902d65c76195467f6ae232caed955b5b247439e27aca59b7e
+  data.tar.gz: bb2b29a3b6d7c3c4b0312103fe98bd8c3744dc42415280fda8bbb41054c414f489954c1ee869f6b21cb4e98a470eb7f7e9cf8fc63cc05c0810d4f1b635c9bd55

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/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