ruby_llm-agents 0.3.4 → 0.3.5

data/app/controllers/concerns/ruby_llm/agents/filterable.rb

@@ -74,7 +74,11 @@ module RubyLLM
       # @param days [Integer, nil] Number of days to filter by
       # @return [ActiveRecord::Relation] Filtered scope
       def apply_time_filter(scope, days)
-        days.present? && days.positive? ? scope.where("created_at >= ?", days.days.ago) : scope
+        return scope unless days.present? && days.positive?
+
+        # Qualify column name to avoid ambiguity when joins are present
+        table_name = scope.model.table_name
+        scope.where("#{table_name}.created_at >= ?", days.days.ago)
       end
     end
   end

data/app/controllers/concerns/ruby_llm/agents/paginatable.rb

@@ -33,7 +33,8 @@ module RubyLLM
         per_page = RubyLLM::Agents.configuration.per_page
         offset = (page - 1) * per_page
 
-        scope = scope.order(created_at: :desc) if ordered
+        # Qualify column name to avoid ambiguity when joins are present
+        scope = scope.order("#{scope.model.table_name}.created_at DESC") if ordered
         total_count = scope.count
 
         {

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

@@ -20,14 +20,33 @@ module RubyLLM
       #
       # Uses AgentRegistry to discover agents from both file system
       # and execution history, ensuring deleted agents with history
-      # are still visible.
+      # are still visible. Separates agents and workflows for tabbed display.
       #
       # @return [void]
       def index
-        @agents = AgentRegistry.all_with_details
+        all_items = AgentRegistry.all_with_details
+
+        # Separate agents and workflows
+        @agents = all_items.reject { |a| a[:is_workflow] }
+        @workflows = all_items.select { |a| a[:is_workflow] }
+
+        # Group workflows by type for sub-tabs
+        @workflows_by_type = {
+          pipeline: @workflows.select { |w| w[:workflow_type] == "pipeline" },
+          parallel: @workflows.select { |w| w[:workflow_type] == "parallel" },
+          router: @workflows.select { |w| w[:workflow_type] == "router" }
+        }
+
+        # Counts for tab badges
+        @agent_count = @agents.size
+        @workflow_count = @workflows.size
       rescue StandardError => e
         Rails.logger.error("[RubyLLM::Agents] Error loading agents: #{e.message}")
         @agents = []
+        @workflows = []
+        @workflows_by_type = { pipeline: [], parallel: [], router: [] }
+        @agent_count = 0
+        @workflow_count = 0
         flash.now[:alert] = "Error loading agents list"
       end
 

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

@@ -20,12 +20,13 @@ module RubyLLM
       def index
         @selected_range = params[:range].presence || "today"
         @days = range_to_days(@selected_range)
-        @now_strip = Execution.now_strip_data(range: @selected_range)
-        @critical_alerts = load_critical_alerts
-        @hourly_activity = Execution.hourly_activity_chart
-        @recent_executions = Execution.recent(10)
-        @agent_stats = build_agent_comparison
-        @top_errors = build_top_errors
+        base_scope = tenant_scoped_executions
+        @now_strip = base_scope.now_strip_data(range: @selected_range)
+        @critical_alerts = load_critical_alerts(base_scope)
+        @recent_executions = base_scope.recent(10)
+        @agent_stats = build_agent_comparison(base_scope)
+        @top_errors = build_top_errors(base_scope)
+        @tenant_budget = load_tenant_budget(base_scope)
       end
 
       # Returns chart data as JSON for live updates
@@ -34,7 +35,7 @@ module RubyLLM
       # @return [JSON] Chart data with series
       def chart_data
         range = params[:range].presence || "today"
-        render json: Execution.activity_chart_json(range: range)
+        render json: tenant_scoped_executions.activity_chart_json(range: range)
       end
 
       private
@@ -54,33 +55,64 @@ module RubyLLM
 
       # Builds per-agent comparison statistics
       #
-      # @return [Array<Hash>] Array of agent stats sorted by cost descending
-      def build_agent_comparison
-        scope = Execution.last_n_days(@days)
+      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
+      # @return [Array<Hash>] Array of all stats sorted by cost descending
+      def build_agent_comparison(base_scope = Execution)
+        scope = base_scope.last_n_days(@days)
         agent_types = scope.distinct.pluck(:agent_type)
 
-        agent_types.map do |agent_type|
+        all_stats = agent_types.map do |agent_type|
           agent_scope = scope.where(agent_type: agent_type)
           count = agent_scope.count
           total_cost = agent_scope.sum(:total_cost) || 0
           successful = agent_scope.successful.count
 
+          # Detect if this is a workflow
+          agent_class = AgentRegistry.find(agent_type)
+          is_workflow = agent_class&.ancestors&.any? { |a| a.name&.include?("Workflow") }
+          workflow_type = is_workflow ? detect_workflow_type(agent_class) : nil
+
           {
             agent_type: agent_type,
             executions: count,
             total_cost: total_cost,
             avg_cost: count > 0 ? (total_cost / count).round(6) : 0,
             avg_duration_ms: agent_scope.average(:duration_ms)&.round || 0,
-            success_rate: count > 0 ? (successful.to_f / count * 100).round(1) : 0
+            success_rate: count > 0 ? (successful.to_f / count * 100).round(1) : 0,
+            is_workflow: is_workflow,
+            workflow_type: workflow_type
           }
         end.sort_by { |a| -(a[:total_cost] || 0) }
+
+        # Split into agents and workflows for tabbed display
+        @workflow_stats = all_stats.select { |a| a[:is_workflow] }
+        all_stats.reject { |a| a[:is_workflow] }
+      end
+
+      # Detects workflow type from class hierarchy
+      #
+      # @param agent_class [Class] The agent class
+      # @return [String, nil] "pipeline", "parallel", "router", or nil
+      def detect_workflow_type(agent_class)
+        return nil unless agent_class
+
+        ancestors = agent_class.ancestors.map { |a| a.name.to_s }
+
+        if ancestors.include?("RubyLLM::Agents::Workflow::Pipeline")
+          "pipeline"
+        elsif ancestors.include?("RubyLLM::Agents::Workflow::Parallel")
+          "parallel"
+        elsif ancestors.include?("RubyLLM::Agents::Workflow::Router")
+          "router"
+        end
       end
 
       # Builds top errors list
       #
+      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
       # @return [Array<Hash>] Top 5 error classes with counts
-      def build_top_errors
-        scope = Execution.last_n_days(@days).where(status: "error")
+      def build_top_errors(base_scope = Execution)
+        scope = base_scope.last_n_days(@days).where(status: "error")
         total_errors = scope.count
 
         scope.group(:error_class)
@@ -187,6 +219,37 @@ module RubyLLM
         []
       end
 
+      # Loads tenant budget info for the current tenant
+      #
+      # @param base_scope [ActiveRecord::Relation] Base scope for usage calculation
+      # @return [Hash, nil] Tenant budget data with usage info, or nil if not applicable
+      def load_tenant_budget(base_scope)
+        return nil unless tenant_filter_enabled? && current_tenant_id.present?
+        return nil unless TenantBudget.table_exists?
+
+        budget = TenantBudget.for_tenant(current_tenant_id)
+        return nil unless budget
+
+        # Calculate current usage
+        today_scope = base_scope.where("created_at >= ?", Time.current.beginning_of_day)
+        month_scope = base_scope.where("created_at >= ?", Time.current.beginning_of_month)
+
+        daily_spend = today_scope.sum(:total_cost) || 0
+        monthly_spend = month_scope.sum(:total_cost) || 0
+
+        {
+          tenant_id: current_tenant_id,
+          daily_limit: budget.effective_daily_limit,
+          monthly_limit: budget.effective_monthly_limit,
+          daily_spend: daily_spend,
+          monthly_spend: monthly_spend,
+          daily_percentage: budget.effective_daily_limit.to_f > 0 ? (daily_spend / budget.effective_daily_limit * 100).round(1) : 0,
+          monthly_percentage: budget.effective_monthly_limit.to_f > 0 ? (monthly_spend / budget.effective_monthly_limit * 100).round(1) : 0,
+          enforcement: budget.effective_enforcement,
+          per_agent_daily: budget.per_agent_daily || {}
+        }
+      end
+
       # Loads recent alerts from cache
       #
       # @return [Array<Hash>] Array of recent alert events
@@ -204,8 +267,9 @@ module RubyLLM
       # Combines open circuit breakers, budget breaches, and error spikes
       # into a single prioritized list (max 3 items).
       #
+      # @param base_scope [ActiveRecord::Relation] Base scope to filter from
       # @return [Array<Hash>] Critical alerts with type and data
-      def load_critical_alerts
+      def load_critical_alerts(base_scope = Execution)
         alerts = []
 
         # Open circuit breakers
@@ -241,7 +305,7 @@ module RubyLLM
         end
 
         # Error spike detection (>5 errors in last 15 minutes)
-        error_count_15m = Execution.status_error.where("created_at > ?", 15.minutes.ago).count
+        error_count_15m = base_scope.status_error.where("created_at > ?", 15.minutes.ago).count
         if error_count_15m >= 5
           alerts << { type: :error_spike, data: { count: error_count_15m } }
         end

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

@@ -155,32 +155,53 @@ module RubyLLM
       # Loads available options for filter dropdowns
       #
       # Populates @agent_types with all agent types that have executions,
-      # @model_ids with all distinct models used, and @statuses with all
-      # possible status values.
+      # @model_ids with all distinct models used, @workflow_types with
+      # workflow patterns used, and @statuses with all possible status values.
       #
       # @return [void]
       def load_filter_options
         @agent_types = available_agent_types
         @model_ids = available_model_ids
+        @workflow_types = available_workflow_types
         @statuses = Execution.statuses.keys
       end
 
       # Returns distinct agent types from execution history
       #
       # Memoized to avoid duplicate queries within a request.
+      # Uses tenant_scoped_executions to respect multi-tenancy filtering.
       #
       # @return [Array<String>] Agent type names
       def available_agent_types
-        @available_agent_types ||= Execution.distinct.pluck(:agent_type)
+        @available_agent_types ||= tenant_scoped_executions.distinct.pluck(:agent_type)
       end
 
       # Returns distinct model IDs from execution history
       #
       # Memoized to avoid duplicate queries within a request.
+      # Uses tenant_scoped_executions to respect multi-tenancy filtering.
       #
       # @return [Array<String>] Model IDs
       def available_model_ids
-        @available_model_ids ||= Execution.where.not(model_id: nil).distinct.pluck(:model_id).sort
+        @available_model_ids ||= tenant_scoped_executions.where.not(model_id: nil).distinct.pluck(:model_id).sort
+      end
+
+      # Returns distinct workflow types from execution history
+      #
+      # Memoized to avoid duplicate queries within a request.
+      # Returns empty array if workflow_type column doesn't exist yet.
+      # Uses tenant_scoped_executions to respect multi-tenancy filtering.
+      #
+      # @return [Array<String>] Workflow types (pipeline, parallel, router)
+      def available_workflow_types
+        return @available_workflow_types if defined?(@available_workflow_types)
+
+        @available_workflow_types = if Execution.column_names.include?("workflow_type")
+                                      tenant_scoped_executions.where.not(workflow_type: [nil, ""])
+                                                              .distinct.pluck(:workflow_type).sort
+                                    else
+                                      []
+                                    end
       end
 
       # Loads paginated executions and associated statistics
@@ -215,7 +236,7 @@ module RubyLLM
       #
       # @return [ActiveRecord::Relation] Filtered execution scope
       def filtered_executions
-        scope = Execution.all
+        scope = tenant_scoped_executions
 
         # Apply search filter
         scope = scope.search(params[:q]) if params[:q].present?
@@ -244,8 +265,65 @@ module RubyLLM
         model_ids = parse_array_param(:model_ids)
         scope = scope.where(model_id: model_ids) if model_ids.any?
 
+        # Apply workflow type filter (only if column exists)
+        if Execution.column_names.include?("workflow_type")
+          workflow_types = parse_array_param(:workflow_types)
+          if workflow_types.any?
+            includes_single = workflow_types.include?("single")
+            other_types = workflow_types - ["single"]
+
+            if includes_single && other_types.any?
+              # Include both single (null workflow_type) and specific workflow types
+              scope = scope.where(workflow_type: [nil, ""] + other_types)
+            elsif includes_single
+              # Only single executions (non-workflow)
+              scope = scope.where(workflow_type: [nil, ""])
+            else
+              # Only specific workflow types
+              scope = scope.where(workflow_type: workflow_types)
+            end
+          end
+        end
+
+        # Apply execution type tab filter (agents vs workflows)
+        scope = apply_execution_type_filter(scope)
+
+        # Only show root executions (not workflow children) - children are nested under parents
+        scope = scope.where(parent_execution_id: nil)
+
+        # Eager load children for workflow grouping
+        scope = scope.includes(:child_executions)
+
         scope
       end
+
+      # Applies execution type tab filter (all, agents, workflows)
+      #
+      # @param scope [ActiveRecord::Relation] The current scope
+      # @return [ActiveRecord::Relation] Filtered scope
+      def apply_execution_type_filter(scope)
+        return scope unless Execution.column_names.include?("workflow_type")
+
+        execution_type = params[:execution_type]
+        case execution_type
+        when "agents"
+          # Only show executions where workflow_type is null/empty (regular agents)
+          scope.where(workflow_type: [nil, ""])
+        when "workflows"
+          # Only show executions with a workflow_type
+          workflow_scope = scope.where.not(workflow_type: [nil, ""])
+
+          # Apply workflow type sub-filter if specified
+          workflow_type_tab = params[:workflow_type_tab]
+          if workflow_type_tab.present? && %w[pipeline parallel router].include?(workflow_type_tab)
+            workflow_scope = workflow_scope.where(workflow_type: workflow_type_tab)
+          end
+
+          workflow_scope
+        else
+          scope
+        end
+      end
     end
   end
 end

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

@@ -190,20 +190,15 @@ module RubyLLM
 
           # Builds hourly chart data for last 24 hours
           # Optimized: Single GROUP BY query instead of 72 individual queries
+          # Database-agnostic: works with both PostgreSQL and SQLite
           def build_hourly_chart_data
             reference_time = Time.current.beginning_of_hour
             start_time = reference_time - 23.hours
 
-            # Single query with GROUP BY - reduces 72 queries to 1
+            # Use database-agnostic aggregation with Ruby post-processing
             results = where(created_at: start_time..(reference_time + 1.hour))
-              .group(Arel.sql("DATE_TRUNC('hour', created_at)"))
-              .select(
-                Arel.sql("DATE_TRUNC('hour', created_at) as time_bucket"),
-                Arel.sql("COUNT(*) FILTER (WHERE status = 'success') as success_count"),
-                Arel.sql("COUNT(*) FILTER (WHERE status IN ('error', 'timeout')) as failed_count"),
-                Arel.sql("COALESCE(SUM(total_cost), 0) as total_cost")
-              )
-              .index_by { |r| r.time_bucket.to_time.beginning_of_hour }
+              .select(:status, :total_cost, :created_at)
+              .group_by { |r| r.created_at.beginning_of_hour }
 
             # Build arrays for all 24 hours (fill missing with zeros)
             success_data = []
@@ -215,11 +210,11 @@ module RubyLLM
 
             (23.downto(0)).each do |hours_ago|
               bucket_time = (reference_time - hours_ago.hours).beginning_of_hour
-              row = results[bucket_time]
+              rows = results[bucket_time] || []
 
-              s = row&.success_count.to_i
-              f = row&.failed_count.to_i
-              c = row&.total_cost.to_f
+              s = rows.count { |r| r.status == "success" }
+              f = rows.count { |r| r.status.in?(%w[error timeout]) }
+              c = rows.sum { |r| r.total_cost.to_f }
 
               success_data << s
               failed_data << f
@@ -242,21 +237,16 @@ module RubyLLM
           end
 
           # Builds daily chart data for specified number of days
-          # Optimized: Single GROUP BY query instead of 3*days individual queries
+          # Optimized: Single query instead of 3*days individual queries
+          # Database-agnostic: works with both PostgreSQL and SQLite
           def build_daily_chart_data(days)
             end_date = Date.current
             start_date = (days - 1).days.ago.to_date
 
-            # Single query with GROUP BY - reduces 3*days queries to 1
+            # Use database-agnostic aggregation with Ruby post-processing
             results = where(created_at: start_date.beginning_of_day..end_date.end_of_day)
-              .group(Arel.sql("DATE_TRUNC('day', created_at)"))
-              .select(
-                Arel.sql("DATE_TRUNC('day', created_at) as time_bucket"),
-                Arel.sql("COUNT(*) FILTER (WHERE status = 'success') as success_count"),
-                Arel.sql("COUNT(*) FILTER (WHERE status IN ('error', 'timeout')) as failed_count"),
-                Arel.sql("COALESCE(SUM(total_cost), 0) as total_cost")
-              )
-              .index_by { |r| r.time_bucket.to_date }
+              .select(:status, :total_cost, :created_at)
+              .group_by { |r| r.created_at.to_date }
 
             # Build arrays for all days (fill missing with zeros)
             success_data = []
@@ -268,11 +258,11 @@ module RubyLLM
 
             (days - 1).downto(0).each do |days_ago|
               date = days_ago.days.ago.to_date
-              row = results[date]
+              rows = results[date] || []
 
-              s = row&.success_count.to_i
-              f = row&.failed_count.to_i
-              c = row&.total_cost.to_f
+              s = rows.count { |r| r.status == "success" }
+              f = rows.count { |r| r.status.in?(%w[error timeout]) }
+              c = rows.sum { |r| r.total_cost.to_f }
 
               success_data << s
               failed_data << f

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

@@ -47,6 +47,31 @@ module RubyLLM
 
           # @!endgroup
 
+          # @!group Tenant Scopes
+
+          # @!method by_tenant(tenant_id)
+          #   Filters to a specific tenant
+          #   @param tenant_id [String] The tenant identifier
+          #   @return [ActiveRecord::Relation]
+
+          # @!method for_current_tenant
+          #   Filters to the current tenant from the resolver
+          #   @return [ActiveRecord::Relation]
+          scope :by_tenant, ->(tenant_id) { where(tenant_id: tenant_id) }
+          scope :without_tenant, -> { where(tenant_id: nil) }
+          scope :with_tenant, -> { where.not(tenant_id: nil) }
+          scope :for_current_tenant, -> {
+            config = RubyLLM::Agents.configuration
+            if config.multi_tenancy_enabled?
+              tenant_id = config.tenant_resolver&.call
+              tenant_id ? where(tenant_id: tenant_id) : all
+            else
+              all
+            end
+          }
+
+          # @!endgroup
+
           # @!group Agent-based Scopes
 
           # @!method by_agent(agent_type)