ruby_llm-agents 1.3.3 → 2.0.0

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class Tenant
+      # Handles lazy reset of usage counters when periods roll over,
+      # and provides refresh_counters! for reconciliation from the executions table.
+      #
+      # @api public
+      module Resettable
+        extend ActiveSupport::Concern
+
+        # Resets daily counters if the day has rolled over.
+        # Uses a WHERE guard to prevent race conditions with concurrent requests.
+        #
+        # @return [void]
+        def ensure_daily_reset!
+          return if daily_reset_date == Date.current
+
+          rows = self.class.where(id: id)
+            .where("daily_reset_date IS NULL OR daily_reset_date < ?", Date.current)
+            .update_all(
+              daily_cost_spent: 0,
+              daily_tokens_used: 0,
+              daily_executions_count: 0,
+              daily_error_count: 0,
+              daily_reset_date: Date.current
+            )
+
+          reload if rows > 0
+        end
+
+        # Resets monthly counters if the month has rolled over.
+        # Uses a WHERE guard to prevent race conditions with concurrent requests.
+        #
+        # @return [void]
+        def ensure_monthly_reset!
+          bom = Date.current.beginning_of_month
+          return if monthly_reset_date == bom
+
+          rows = self.class.where(id: id)
+            .where("monthly_reset_date IS NULL OR monthly_reset_date < ?", bom)
+            .update_all(
+              monthly_cost_spent: 0,
+              monthly_tokens_used: 0,
+              monthly_executions_count: 0,
+              monthly_error_count: 0,
+              monthly_reset_date: bom
+            )
+
+          reload if rows > 0
+        end
+
+        # Recalculates all counters from the source-of-truth executions table.
+        #
+        # Use when counters have drifted due to manual DB edits, failed writes,
+        # or after deleting/updating execution records.
+        #
+        # @return [void]
+        def refresh_counters!
+          today = Date.current
+          bom = today.beginning_of_month
+
+          daily_stats = aggregate_stats(
+            executions.where("created_at >= ?", today.beginning_of_day)
+          )
+          monthly_stats = aggregate_stats(
+            executions.where("created_at >= ?", bom.beginning_of_day)
+          )
+
+          last_exec = executions.order(created_at: :desc).pick(:created_at, :status)
+
+          update_columns(
+            daily_cost_spent:        daily_stats[:cost],
+            daily_tokens_used:       daily_stats[:tokens],
+            daily_executions_count:  daily_stats[:count],
+            daily_error_count:       daily_stats[:errors],
+            daily_reset_date:        today,
+
+            monthly_cost_spent:       monthly_stats[:cost],
+            monthly_tokens_used:      monthly_stats[:tokens],
+            monthly_executions_count: monthly_stats[:count],
+            monthly_error_count:      monthly_stats[:errors],
+            monthly_reset_date:       bom,
+
+            last_execution_at:     last_exec&.first,
+            last_execution_status: last_exec&.last
+          )
+
+          reload
+        end
+
+        class_methods do
+          # Refresh counters for all tenants
+          #
+          # @return [void]
+          def refresh_all_counters!
+            find_each(&:refresh_counters!)
+          end
+
+          # Refresh counters for active tenants only
+          #
+          # @return [void]
+          def refresh_active_counters!
+            active.find_each(&:refresh_counters!)
+          end
+        end
+
+        private
+
+        # Aggregates cost, tokens, count, and errors from an executions scope.
+        #
+        # @param scope [ActiveRecord::Relation]
+        # @return [Hash] { cost:, tokens:, count:, errors: }
+        def aggregate_stats(scope)
+          agg = scope.pick(
+            Arel.sql("COALESCE(SUM(total_cost), 0)"),
+            Arel.sql("COALESCE(SUM(total_tokens), 0)"),
+            Arel.sql("COUNT(*)"),
+            Arel.sql("COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0)")
+          )
+
+          { cost: agg[0], tokens: agg[1], count: agg[2], errors: agg[3] }
+        end
+      end
+    end
+  end
+end

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

@@ -50,11 +50,12 @@ module RubyLLM
           scope.sum(:total_cost) || 0
         end
 
-        # Returns today's cost
+        # Returns today's cost from counter columns
         #
         # @return [Float]
         def cost_today
-          cost(period: :today)
+          ensure_daily_reset!
+          daily_cost_spent
         end
 
         # Returns yesterday's cost
@@ -78,11 +79,12 @@ module RubyLLM
           cost(period: :last_week)
         end
 
-        # Returns this month's cost
+        # Returns this month's cost from counter columns
         #
         # @return [Float]
         def cost_this_month
-          cost(period: :this_month)
+          ensure_monthly_reset!
+          monthly_cost_spent
         end
 
         # Returns last month's cost
@@ -104,11 +106,12 @@ module RubyLLM
           scope.sum(:total_tokens) || 0
         end
 
-        # Returns today's token usage
+        # Returns today's token usage from counter columns
         #
         # @return [Integer]
         def tokens_today
-          tokens(period: :today)
+          ensure_daily_reset!
+          daily_tokens_used
         end
 
         # Returns yesterday's token usage
@@ -125,11 +128,12 @@ module RubyLLM
           tokens(period: :this_week)
         end
 
-        # Returns this month's token usage
+        # Returns this month's token usage from counter columns
         #
         # @return [Integer]
         def tokens_this_month
-          tokens(period: :this_month)
+          ensure_monthly_reset!
+          monthly_tokens_used
         end
 
         # Returns last month's token usage
@@ -151,11 +155,12 @@ module RubyLLM
           scope.count
         end
 
-        # Returns today's execution count
+        # Returns today's execution count from counter columns
         #
         # @return [Integer]
         def executions_today
-          execution_count(period: :today)
+          ensure_daily_reset!
+          daily_executions_count
         end
 
         # Returns yesterday's execution count
@@ -172,11 +177,12 @@ module RubyLLM
           execution_count(period: :this_week)
         end
 
-        # Returns this month's execution count
+        # Returns this month's execution count from counter columns
         #
         # @return [Integer]
         def executions_this_month
-          execution_count(period: :this_month)
+          ensure_monthly_reset!
+          monthly_executions_count
         end
 
         # Returns last month's execution count
@@ -186,6 +192,34 @@ module RubyLLM
           execution_count(period: :last_month)
         end
 
+        # Error count queries
+
+        # Returns today's error count from counter columns
+        #
+        # @return [Integer]
+        def errors_today
+          ensure_daily_reset!
+          daily_error_count
+        end
+
+        # Returns this month's error count from counter columns
+        #
+        # @return [Integer]
+        def errors_this_month
+          ensure_monthly_reset!
+          monthly_error_count
+        end
+
+        # Returns today's success rate from counter columns
+        #
+        # @return [Float] Percentage (0.0-100.0)
+        def success_rate_today
+          ensure_daily_reset!
+          return 100.0 if daily_executions_count.zero?
+
+          ((daily_executions_count - daily_error_count).to_f / daily_executions_count * 100).round(1)
+        end
+
         # Usage summaries
 
         # Returns a complete usage summary for the tenant

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

@@ -7,7 +7,6 @@ module RubyLLM
     # Encapsulates all tenant-related functionality:
     # - Budget limits and enforcement (via Budgetable concern)
     # - Usage tracking: cost, tokens, executions (via Trackable concern)
-    # - API configuration per tenant (via Configurable concern)
     #
     # @example Creating a tenant
     #   Tenant.create!(
@@ -30,7 +29,6 @@ module RubyLLM
     #
     # @see Tenant::Budgetable
     # @see Tenant::Trackable
-    # @see Tenant::Configurable
     # @see LLMTenant
     # @api public
     class Tenant < ::ActiveRecord::Base
@@ -39,7 +37,8 @@ module RubyLLM
       # Include concerns for organized functionality
       include Tenant::Budgetable
       include Tenant::Trackable
-      include Tenant::Configurable
+      include Tenant::Resettable
+      include Tenant::Incrementable
 
       # Polymorphic association to user's tenant model (optional)
       # Allows linking to Organization, Account, or any ActiveRecord model

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

@@ -8,15 +8,18 @@ module RubyLLM
     # All functionality has been moved to the Tenant model with organized concerns.
     #
     # @example Migration path
-    #   # Old usage (still works)
+    #   # Old usage (still works but emits deprecation warning)
     #   TenantBudget.for_tenant("acme_corp")
-    #   TenantBudget.create!(tenant_id: "acme", daily_limit: 100)
     #
     #   # New usage (preferred)
     #   Tenant.for("acme_corp")
-    #   Tenant.create!(tenant_id: "acme", daily_limit: 100)
     #
     # @see Tenant
     TenantBudget = Tenant
+
+    ActiveSupport.deprecator.warn(
+      "RubyLLM::Agents::TenantBudget is deprecated. Use RubyLLM::Agents::Tenant instead. " \
+      "This alias will be removed in the next major version."
+    )
   end
 end

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

@@ -21,12 +21,6 @@ module RubyLLM
     #
     # @api public
     class AgentRegistry
-      # Base workflow classes to exclude from listings
-      # These are abstract parent classes, not concrete workflows
-      BASE_WORKFLOW_CLASSES = [
-        "RubyLLM::Agents::Workflow"
-      ].freeze
-
       class << self
         # Returns all unique agent type names
         #
@@ -66,22 +60,17 @@ module RubyLLM
         #
         # @return [Array<String>] Agent class names
         def file_system_agents
-          # Ensure all agent and workflow classes are loaded
+          # Ensure all agent classes are loaded
           eager_load_agents!
 
           # Find all descendants of all base classes
           agents = RubyLLM::Agents::Base.descendants.map(&:name).compact
-          workflows = RubyLLM::Agents::Workflow.descendants.map(&:name).compact
           embedders = RubyLLM::Agents::Embedder.descendants.map(&:name).compact
-          moderators = RubyLLM::Agents::Moderator.descendants.map(&:name).compact
           speakers = RubyLLM::Agents::Speaker.descendants.map(&:name).compact
           transcribers = RubyLLM::Agents::Transcriber.descendants.map(&:name).compact
           image_generators = RubyLLM::Agents::ImageGenerator.descendants.map(&:name).compact
 
-          all_agents = (agents + workflows + embedders + moderators + speakers + transcribers + image_generators).uniq
-
-          # Filter out base workflow classes
-          all_agents.reject { |name| BASE_WORKFLOW_CLASSES.include?(name) }
+          (agents + embedders + speakers + transcribers + image_generators).uniq
         rescue StandardError => e
           Rails.logger.error("[RubyLLM::Agents] Error loading agents from file system: #{e.message}")
           []
@@ -97,7 +86,7 @@ module RubyLLM
           []
         end
 
-        # Eager loads all agent and workflow files to register descendants
+        # Eager loads all agent files to register descendants
         #
         # Uses the configured autoload paths from RubyLLM::Agents.configuration
         # to ensure agents are discovered in the correct directories.
@@ -116,28 +105,6 @@ module RubyLLM
           end
         end
 
-        # Returns only regular agents (non-workflows)
-        #
-        # @return [Array<Hash>] Agent info hashes for non-workflow agents
-        def agents_only
-          all_with_details.reject { |a| a[:is_workflow] }
-        end
-
-        # Returns only workflows
-        #
-        # @return [Array<Hash>] Agent info hashes for workflows only
-        def workflows_only
-          all_with_details.select { |a| a[:is_workflow] }
-        end
-
-        # Returns workflows filtered by type
-        #
-        # @param type [String, Symbol] The workflow type (pipeline, parallel, router)
-        # @return [Array<Hash>] Filtered workflow info hashes
-        def workflows_by_type(type)
-          workflows_only.select { |w| w[:workflow_type] == type.to_s }
-        end
-
         # Builds detailed info hash for an agent
         #
         # @param agent_type [String] The agent class name
@@ -146,27 +113,17 @@ module RubyLLM
           agent_class = find(agent_type)
           stats = fetch_stats(agent_type)
 
-          # Detect the agent type (agent, workflow, embedder, moderator, speaker, transcriber)
+          # Detect the agent type (agent, embedder, speaker, transcriber, image_generator)
           detected_type = detect_agent_type(agent_class)
 
-          # Check if this is a workflow class vs a regular agent
-          is_workflow = detected_type == "workflow"
-
-          # Determine specific workflow type and children
-          workflow_type = is_workflow ? detect_workflow_type(agent_class) : nil
-          workflow_children = is_workflow ? extract_workflow_children(agent_class) : []
-
           {
             name: agent_type,
             class: agent_class,
             active: agent_class.present?,
             agent_type: detected_type,
-            is_workflow: is_workflow,
-            workflow_type: workflow_type,
-            workflow_children: workflow_children,
             version: safe_call(agent_class, :version) || "N/A",
             description: safe_call(agent_class, :description),
-            model: safe_call(agent_class, :model) || (is_workflow ? "workflow" : "N/A"),
+            model: safe_call(agent_class, :model) || "N/A",
             temperature: safe_call(agent_class, :temperature),
             timeout: safe_call(agent_class, :timeout),
             cache_enabled: safe_call(agent_class, :cache_enabled?) || false,
@@ -216,22 +173,10 @@ module RubyLLM
           nil
         end
 
-        # Detects the specific workflow type from class hierarchy
-        #
-        # @param agent_class [Class, nil] The agent class
-        # @return [String, nil] "workflow" for DSL workflows, or nil
-        def detect_workflow_type(agent_class)
-          return nil unless agent_class
-
-          if agent_class.respond_to?(:step_configs) && agent_class.step_configs.any?
-            "workflow"
-          end
-        end
-
         # Detects the agent type from class hierarchy
         #
         # @param agent_class [Class, nil] The agent class
-        # @return [String] "agent", "workflow", "embedder", "moderator", "speaker", "transcriber", or "image_generator"
+        # @return [String] "agent", "embedder", "speaker", "transcriber", or "image_generator"
         def detect_agent_type(agent_class)
           return "agent" unless agent_class
 
@@ -239,67 +184,16 @@ module RubyLLM
 
           if ancestors.include?("RubyLLM::Agents::Embedder")
             "embedder"
-          elsif ancestors.include?("RubyLLM::Agents::Moderator")
-            "moderator"
           elsif ancestors.include?("RubyLLM::Agents::Speaker")
             "speaker"
           elsif ancestors.include?("RubyLLM::Agents::Transcriber")
             "transcriber"
           elsif ancestors.include?("RubyLLM::Agents::ImageGenerator")
             "image_generator"
-          elsif ancestors.include?("RubyLLM::Agents::Workflow")
-            "workflow"
           else
             "agent"
           end
         end
-
-        # Extracts child agents from workflow DSL configuration
-        #
-        # @param agent_class [Class, nil] The workflow class
-        # @return [Array<Hash>] Array of child info hashes with :name, :agent, :type, :optional keys
-        def extract_workflow_children(agent_class)
-          return [] unless agent_class
-
-          children = []
-
-          if agent_class.respond_to?(:steps) && agent_class.steps.any?
-            # Pipeline workflow - extract steps
-            agent_class.steps.each do |name, config|
-              children << {
-                name: name,
-                agent: config[:agent]&.name,
-                type: "step",
-                optional: config[:continue_on_error] || false
-              }
-            end
-          elsif agent_class.respond_to?(:branches) && agent_class.branches.any?
-            # Parallel workflow - extract branches
-            agent_class.branches.each do |name, config|
-              children << {
-                name: name,
-                agent: config[:agent]&.name,
-                type: "branch",
-                optional: config[:optional] || false
-              }
-            end
-          elsif agent_class.respond_to?(:routes) && agent_class.routes.any?
-            # Router workflow - extract routes
-            agent_class.routes.each do |name, config|
-              children << {
-                name: name,
-                agent: config[:agent]&.name,
-                type: "route",
-                description: config[:description]
-              }
-            end
-          end
-
-          children
-        rescue StandardError => e
-          Rails.logger.error("[RubyLLM::Agents] Error extracting workflow children: #{e.message}")
-          []
-        end
       end
     end
   end