ruby_llm-agents 1.3.3 → 2.0.0

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

@@ -82,58 +82,6 @@ module RubyLLM
           end
 
           # Compares performance between two agent versions
-          #
-          # @param agent_type [String] The agent class name
-          # @param version1 [String] First version to compare (baseline)
-          # @param version2 [String] Second version to compare
-          # @param period [Symbol] Time scope for comparison
-          # @return [Hash] Comparison data with stats for each version and improvement percentages
-          def compare_versions(agent_type, version1, version2, period: :this_week)
-            base_scope = by_agent(agent_type).public_send(period)
-
-            v1_stats = stats_for_scope(base_scope.by_version(version1))
-            v2_stats = stats_for_scope(base_scope.by_version(version2))
-
-            {
-              agent_type: agent_type,
-              period: period,
-              version1: { version: version1, **v1_stats },
-              version2: { version: version2, **v2_stats },
-              improvements: {
-                cost_change_pct: percent_change(v1_stats[:avg_cost], v2_stats[:avg_cost]),
-                token_change_pct: percent_change(v1_stats[:avg_tokens], v2_stats[:avg_tokens]),
-                speed_change_pct: percent_change(v1_stats[:avg_duration_ms], v2_stats[:avg_duration_ms])
-              }
-            }
-          end
-
-          # Returns daily trend data for a specific agent version
-          #
-          # Used for sparkline charts in version comparison.
-          #
-          # @param agent_type [String] The agent class name
-          # @param version [String] The version to analyze
-          # @param days [Integer] Number of days to analyze
-          # @return [Array<Hash>] Daily metrics sorted oldest to newest
-          def version_trend_data(agent_type, version, days: 14)
-            scope = by_agent(agent_type).by_version(version)
-
-            (0...days).map do |days_ago|
-              date = days_ago.days.ago.to_date
-              day_scope = scope.where(created_at: date.beginning_of_day..date.end_of_day)
-              count = day_scope.count
-
-              {
-                date: date,
-                count: count,
-                success_rate: calculate_success_rate(day_scope),
-                avg_cost: count > 0 ? ((day_scope.total_cost_sum || 0) / count).round(6) : 0,
-                avg_duration_ms: day_scope.avg_duration&.round || 0,
-                avg_tokens: day_scope.avg_tokens&.round || 0
-              }
-            end.reverse
-          end
-
           # Analyzes trends over a time period
           #
           # @param agent_type [String, nil] Filter to specific agent, or nil for all
@@ -526,9 +474,18 @@ module RubyLLM
 
           # Average time to first token for streaming executions
           #
+          # time_to_first_token_ms is stored in metadata JSON, so we use
+          # Ruby-level calculation instead of SQL aggregation.
+          #
           # @return [Integer, nil] Average TTFT in milliseconds, or nil if no data
           def avg_time_to_first_token
-            streaming.where.not(time_to_first_token_ms: nil).average(:time_to_first_token_ms)&.round(0)
+            ttft_values = streaming
+              .where("metadata IS NOT NULL")
+              .pluck(:metadata)
+              .filter_map { |m| m&.dig("time_to_first_token_ms") }
+            return nil if ttft_values.empty?
+
+            (ttft_values.sum.to_f / ttft_values.size).round(0)
           end
 
           # Finish reason distribution
@@ -540,9 +497,11 @@ module RubyLLM
 
           # Rate limited execution count
           #
+          # rate_limited is stored in metadata JSON
+          #
           # @return [Integer] Number of executions that were rate limited
           def rate_limited_count
-            where(rate_limited: true).count
+            metadata_true("rate_limited").count
           end
 
           # Rate limited rate percentage

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

@@ -79,17 +79,11 @@ module RubyLLM
           #   @param agent_type [String] The agent class name
           #   @return [ActiveRecord::Relation]
 
-          # @!method by_version(version)
-          #   Filters to a specific agent version
-          #   @param version [String] The version string
-          #   @return [ActiveRecord::Relation]
-
           # @!method by_model(model_id)
           #   Filters to a specific LLM model
           #   @param model_id [String] The model identifier
           #   @return [ActiveRecord::Relation]
           scope :by_agent, ->(agent_type) { where(agent_type: agent_type.to_s) }
-          scope :by_version, ->(version) { where(agent_version: version.to_s) }
           scope :by_model, ->(model_id) { where(model_id: model_id.to_s) }
 
           # @!endgroup
@@ -142,15 +136,25 @@ module RubyLLM
           # @!group Parameter Scopes
 
           # @!method with_parameter(key, value = nil)
-          #   Filters by JSONB parameter key/value
+          #   Filters by parameter key/value in the execution_details table
           #   @param key [String, Symbol] Parameter key to check
           #   @param value [Object, nil] Optional value to match
           #   @return [ActiveRecord::Relation]
           scope :with_parameter, ->(key, value = nil) do
-            if value
-              where("parameters @> ?", { key => value }.to_json)
+            detail_table = RubyLLM::Agents::ExecutionDetail.table_name
+            joined = joins(:detail)
+            if connection.adapter_name.downcase.include?("sqlite")
+              if value
+                joined.where("json_extract(#{detail_table}.parameters, ?) = ?", "$.#{key}", value.to_s)
+              else
+                joined.where("json_extract(#{detail_table}.parameters, ?) IS NOT NULL", "$.#{key}")
+              end
             else
-              where("parameters ? :key", key: key.to_s)
+              if value
+                joined.where("#{detail_table}.parameters @> ?", { key => value }.to_json)
+              else
+                joined.where("#{detail_table}.parameters ? :key", key: key.to_s)
+              end
             end
           end
 
@@ -196,10 +200,12 @@ module RubyLLM
           # @!method rate_limited
           #   Returns executions that were rate limited
           #   @return [ActiveRecord::Relation]
-          scope :with_fallback, -> { where.not(fallback_reason: nil) }
-          scope :retryable_errors, -> { where(retryable: true) }
-          scope :rate_limited, -> { where(rate_limited: true) }
-          scope :by_fallback_reason, ->(reason) { where(fallback_reason: reason) }
+          #
+          # Note: fallback_reason, retryable, and rate_limited are stored in metadata JSON
+          scope :with_fallback, -> { metadata_present("fallback_reason") }
+          scope :retryable_errors, -> { metadata_true("retryable") }
+          scope :rate_limited, -> { metadata_true("rate_limited") }
+          scope :by_fallback_reason, ->(reason) { metadata_value("fallback_reason", reason) }
 
           # @!endgroup
 
@@ -269,6 +275,47 @@ module RubyLLM
         # They can be called on scoped relations.
 
         class_methods do
+          # Database-agnostic JSON metadata queries
+          # These fields (fallback_reason, retryable, rate_limited, etc.) are stored
+          # in the metadata JSON column rather than as direct columns.
+
+          # Queries for metadata key presence (IS NOT NULL)
+          #
+          # @param key [String] The metadata key
+          # @return [ActiveRecord::Relation]
+          def metadata_present(key)
+            if connection.adapter_name.downcase.include?("sqlite")
+              where("json_extract(metadata, ?) IS NOT NULL", "$.#{key}")
+            else
+              where("metadata->>? IS NOT NULL", key.to_s)
+            end
+          end
+
+          # Queries for metadata boolean value being true
+          #
+          # @param key [String] The metadata key
+          # @return [ActiveRecord::Relation]
+          def metadata_true(key)
+            if connection.adapter_name.downcase.include?("sqlite")
+              where("json_extract(metadata, ?) = 1", "$.#{key}")
+            else
+              where("metadata @> ?", { key.to_s => true }.to_json)
+            end
+          end
+
+          # Queries for metadata key matching a specific value
+          #
+          # @param key [String] The metadata key
+          # @param value [Object] The value to match
+          # @return [ActiveRecord::Relation]
+          def metadata_value(key, value)
+            if connection.adapter_name.downcase.include?("sqlite")
+              where("json_extract(metadata, ?) = ?", "$.#{key}", value.to_s)
+            else
+              where("metadata->>? = ?", key.to_s, value.to_s)
+            end
+          end
+
           # Returns sum of total_cost for the current scope
           #
           # @return [Float, nil] Total cost in USD

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

@@ -8,8 +8,6 @@ module RubyLLM
     #
     # @!attribute [rw] agent_type
     #   @return [String] Full class name of the agent (e.g., "SearchAgent")
-    # @!attribute [rw] agent_version
-    #   @return [String] Version string for cache invalidation
     # @!attribute [rw] model_id
     #   @return [String] LLM model identifier used
     # @!attribute [rw] temperature
@@ -37,7 +35,7 @@ module RubyLLM
     # @!attribute [rw] parameters
     #   @return [Hash] Sanitized parameters passed to the agent
     # @!attribute [rw] metadata
-    #   @return [Hash] Custom metadata from execution_metadata hook
+    #   @return [Hash] Custom metadata from metadata hook
     # @!attribute [rw] error_class
     #   @return [String, nil] Exception class name if failed
     # @!attribute [rw] error_message
@@ -51,7 +49,6 @@ module RubyLLM
       include Execution::Metrics
       include Execution::Scopes
       include Execution::Analytics
-      include Execution::Workflow
 
       # Status enum
       # - running: execution in progress
@@ -72,20 +69,25 @@ module RubyLLM
       has_many :child_executions, class_name: "RubyLLM::Agents::Execution",
                foreign_key: :parent_execution_id, dependent: :nullify, inverse_of: :parent_execution
 
-      # Polymorphic association to tenant model (for llm_tenant DSL)
-      belongs_to :tenant_record, polymorphic: true, optional: true
+      # Detail record for large payloads (prompts, responses, tool calls, etc.)
+      has_one :detail, class_name: "RubyLLM::Agents::ExecutionDetail",
+              foreign_key: :execution_id, dependent: :destroy
+
+      # Delegations so existing code keeps working transparently
+      delegate :system_prompt, :user_prompt, :response, :error_message,
+               :messages_summary, :tool_calls, :attempts, :fallback_chain,
+               :parameters, :routed_to, :classification_result,
+               :cached_at, :cache_creation_tokens,
+               to: :detail, prefix: false, allow_nil: true
 
       # Validations
       validates :agent_type, :model_id, :started_at, presence: true
       validates :status, inclusion: { in: statuses.keys }
-      validates :agent_version, presence: true
       validates :temperature, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 2 }, allow_nil: true
       validates :input_tokens, :output_tokens, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
       validates :duration_ms, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
       validates :input_cost, :output_cost, :total_cost, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
       validates :finish_reason, inclusion: { in: FINISH_REASONS }, allow_nil: true
-      validates :fallback_reason, inclusion: { in: FALLBACK_REASONS }, allow_nil: true
-      validates :time_to_first_token_ms, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
 
       before_save :calculate_total_tokens, if: -> { input_tokens_changed? || output_tokens_changed? }
       before_save :calculate_total_cost, if: -> { input_cost_changed? || output_cost_changed? }
@@ -205,7 +207,41 @@ module RubyLLM
       #
       # @return [Boolean] true if rate limiting occurred
       def rate_limited?
-        rate_limited == true
+        metadata&.dig("rate_limited") == true
+      end
+
+      # Convenience accessors for niche fields stored in metadata JSON
+      %w[span_id response_cache_key fallback_reason].each do |field|
+        define_method(field) { metadata&.dig(field) }
+        define_method(:"#{field}=") { |val| self.metadata = (metadata || {}).merge(field => val) }
+      end
+
+      %w[time_to_first_token_ms].each do |field|
+        define_method(field) { metadata&.dig(field)&.to_i }
+        define_method(:"#{field}=") { |val| self.metadata = (metadata || {}).merge(field => val) }
+      end
+
+      def retryable
+        metadata&.dig("retryable")
+      end
+
+      def retryable=(val)
+        self.metadata = (metadata || {}).merge("retryable" => val)
+      end
+
+      def rate_limited
+        metadata&.dig("rate_limited")
+      end
+
+      def rate_limited=(val)
+        self.metadata = (metadata || {}).merge("rate_limited" => val)
+      end
+
+      # Convenience method to access tenant_record through the tenant
+      def tenant_record
+        return nil unless tenant_id.present?
+
+        Tenant.find_by(tenant_id: tenant_id)&.tenant_record
       end
 
       # Returns whether this execution used streaming

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Stores large payload data for an execution (prompts, responses, tool calls, etc.)
+    #
+    # Separated from {Execution} to keep the main table lean for analytics queries.
+    # Only created when there is detail data to store.
+    #
+    # @see Execution
+    # @api public
+    class ExecutionDetail < ::ActiveRecord::Base
+      self.table_name = "ruby_llm_agents_execution_details"
+
+      belongs_to :execution, class_name: "RubyLLM::Agents::Execution"
+    end
+  end
+end

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

@@ -170,17 +170,30 @@ module RubyLLM
           effective_enforcement == :soft
         end
 
-        # Check if within budget for a specific type
+        # Check if within budget for a specific type using counter columns
         #
         # @param type [Symbol] :daily_cost, :monthly_cost, :daily_tokens,
         #   :monthly_tokens, :daily_executions, :monthly_executions
         # @return [Boolean]
         def within_budget?(type: :daily_cost)
-          status = budget_status
-          return true unless status[:enabled]
+          return true unless budgets_enabled?
 
-          key = budget_status_key(type)
-          (status.dig(key, :percentage_used) || 0) < 100
+          case type
+          when :daily_cost
+            within_daily_cost_budget?
+          when :monthly_cost
+            within_monthly_cost_budget?
+          when :daily_tokens
+            within_daily_token_budget?
+          when :monthly_tokens
+            within_monthly_token_budget?
+          when :daily_executions
+            within_daily_execution_budget?
+          when :monthly_executions
+            within_monthly_execution_budget?
+          else
+            true
+          end
         end
 
         # Get remaining budget for a specific type
@@ -188,9 +201,20 @@ module RubyLLM
         # @param type [Symbol] Budget type (see #within_budget?)
         # @return [Numeric, nil]
         def remaining_budget(type: :daily_cost)
-          status = budget_status
-          key = budget_status_key(type)
-          status.dig(key, :remaining)
+          case type
+          when :daily_cost
+            effective_daily_limit && (ensure_daily_reset!; effective_daily_limit - daily_cost_spent)
+          when :monthly_cost
+            effective_monthly_limit && (ensure_monthly_reset!; effective_monthly_limit - monthly_cost_spent)
+          when :daily_tokens
+            effective_daily_token_limit && (ensure_daily_reset!; effective_daily_token_limit - daily_tokens_used)
+          when :monthly_tokens
+            effective_monthly_token_limit && (ensure_monthly_reset!; effective_monthly_token_limit - monthly_tokens_used)
+          when :daily_executions
+            effective_daily_execution_limit && (ensure_daily_reset!; effective_daily_execution_limit - daily_executions_count)
+          when :monthly_executions
+            effective_monthly_execution_limit && (ensure_monthly_reset!; effective_monthly_execution_limit - monthly_executions_count)
+          end
         end
 
         # Check budget and raise if exceeded (for hard enforcement)
@@ -198,14 +222,98 @@ module RubyLLM
         # @param agent_type [String] The agent class name
         # @raise [BudgetExceededError] If hard enforcement and over budget
         def check_budget!(agent_type = nil)
-          BudgetTracker.check_budget!(agent_type || "Unknown", tenant_id: tenant_id)
+          return unless budgets_enabled?
+          return unless hard_enforcement?
+
+          ensure_daily_reset!
+          ensure_monthly_reset!
+
+          if effective_daily_limit && daily_cost_spent >= effective_daily_limit
+            raise Reliability::BudgetExceededError.new(
+              :global_daily, effective_daily_limit, daily_cost_spent, tenant_id: tenant_id
+            )
+          end
+
+          if effective_monthly_limit && monthly_cost_spent >= effective_monthly_limit
+            raise Reliability::BudgetExceededError.new(
+              :global_monthly, effective_monthly_limit, monthly_cost_spent, tenant_id: tenant_id
+            )
+          end
+
+          if effective_daily_token_limit && daily_tokens_used >= effective_daily_token_limit
+            raise Reliability::BudgetExceededError.new(
+              :global_daily_tokens, effective_daily_token_limit, daily_tokens_used, tenant_id: tenant_id
+            )
+          end
+
+          if effective_monthly_token_limit && monthly_tokens_used >= effective_monthly_token_limit
+            raise Reliability::BudgetExceededError.new(
+              :global_monthly_tokens, effective_monthly_token_limit, monthly_tokens_used, tenant_id: tenant_id
+            )
+          end
+
+          if effective_daily_execution_limit && daily_executions_count >= effective_daily_execution_limit
+            raise Reliability::BudgetExceededError.new(
+              :global_daily_executions, effective_daily_execution_limit, daily_executions_count, tenant_id: tenant_id
+            )
+          end
+
+          if effective_monthly_execution_limit && monthly_executions_count >= effective_monthly_execution_limit
+            raise Reliability::BudgetExceededError.new(
+              :global_monthly_executions, effective_monthly_execution_limit, monthly_executions_count, tenant_id: tenant_id
+            )
+          end
         end
 
-        # Get full budget status from BudgetTracker
+        # Get full budget status using counter columns
         #
         # @return [Hash] Budget status with usage information
         def budget_status
-          BudgetTracker.status(tenant_id: tenant_id)
+          ensure_daily_reset!
+          ensure_monthly_reset!
+
+          {
+            enabled: budgets_enabled?,
+            enforcement: effective_enforcement,
+            global_daily: budget_status_for(effective_daily_limit, daily_cost_spent),
+            global_monthly: budget_status_for(effective_monthly_limit, monthly_cost_spent),
+            global_daily_tokens: budget_status_for(effective_daily_token_limit, daily_tokens_used),
+            global_monthly_tokens: budget_status_for(effective_monthly_token_limit, monthly_tokens_used),
+            global_daily_executions: budget_status_for(effective_daily_execution_limit, daily_executions_count),
+            global_monthly_executions: budget_status_for(effective_monthly_execution_limit, monthly_executions_count)
+          }
+        end
+
+        # Individual budget check methods
+
+        def within_daily_cost_budget?
+          ensure_daily_reset!
+          effective_daily_limit.nil? || daily_cost_spent < effective_daily_limit
+        end
+
+        def within_monthly_cost_budget?
+          ensure_monthly_reset!
+          effective_monthly_limit.nil? || monthly_cost_spent < effective_monthly_limit
+        end
+
+        def within_daily_token_budget?
+          ensure_daily_reset!
+          effective_daily_token_limit.nil? || daily_tokens_used < effective_daily_token_limit
+        end
+
+        def within_monthly_token_budget?
+          ensure_monthly_reset!
+          effective_monthly_token_limit.nil? || monthly_tokens_used < effective_monthly_token_limit
+        end
+
+        def within_daily_execution_budget?
+          ensure_daily_reset!
+          effective_daily_execution_limit.nil? || daily_executions_count < effective_daily_execution_limit
+        end
+
+        def within_monthly_execution_budget?
+          ensure_monthly_reset!
+          effective_monthly_execution_limit.nil? || monthly_executions_count < effective_monthly_execution_limit
         end
 
         # Convert to config hash for BudgetTracker
@@ -256,20 +364,20 @@ module RubyLLM
           (global_config&.dig(:per_agent_monthly) || {}).merge(per_agent_monthly || {})
         end
 
-        # Maps budget type to status key
+        # Builds a status hash for a single budget dimension
         #
-        # @param type [Symbol]
-        # @return [Symbol]
-        def budget_status_key(type)
-          case type
-          when :daily_cost then :global_daily
-          when :monthly_cost then :global_monthly
-          when :daily_tokens then :global_daily_tokens
-          when :monthly_tokens then :global_monthly_tokens
-          when :daily_executions then :global_daily_executions
-          when :monthly_executions then :global_monthly_executions
-          else :global_daily
-          end
+        # @param limit [Numeric, nil] The configured limit
+        # @param current [Numeric] The current usage
+        # @return [Hash, nil]
+        def budget_status_for(limit, current)
+          return nil unless limit
+
+          {
+            limit: limit,
+            current_spend: current,
+            remaining: [limit - current, 0].max,
+            percentage_used: (current.to_f / limit * 100).round(1)
+          }
         end
       end
     end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class Tenant
+      # Provides atomic SQL increment of usage counters after each execution.
+      #
+      # @example Recording an execution
+      #   tenant.record_execution!(cost: 0.05, tokens: 1200)
+      #   tenant.record_execution!(cost: 0.01, tokens: 500, error: true)
+      #
+      # @api public
+      module Incrementable
+        extend ActiveSupport::Concern
+
+        # Records an execution by atomically incrementing all counter columns.
+        #
+        # @param cost [Numeric] The cost of the execution in USD
+        # @param tokens [Integer] The number of tokens used
+        # @param error [Boolean] Whether the execution was an error
+        # @return [void]
+        def record_execution!(cost:, tokens:, error: false)
+          ensure_daily_reset!
+          ensure_monthly_reset!
+
+          error_inc = error ? 1 : 0
+          status = error ? "error" : "success"
+
+          self.class.where(id: id).update_all(
+            self.class.sanitize_sql_array([
+              <<~SQL,
+                daily_cost_spent = daily_cost_spent + ?,
+                monthly_cost_spent = monthly_cost_spent + ?,
+                daily_tokens_used = daily_tokens_used + ?,
+                monthly_tokens_used = monthly_tokens_used + ?,
+                daily_executions_count = daily_executions_count + 1,
+                monthly_executions_count = monthly_executions_count + 1,
+                daily_error_count = daily_error_count + ?,
+                monthly_error_count = monthly_error_count + ?,
+                last_execution_at = ?,
+                last_execution_status = ?
+              SQL
+              cost.to_f, cost.to_f,
+              tokens.to_i, tokens.to_i,
+              error_inc, error_inc,
+              Time.current, status
+            ])
+          )
+
+          reload
+          check_soft_cap_alerts!
+        end
+
+        private
+
+        # Checks soft cap alerts after recording an execution.
+        #
+        # @return [void]
+        def check_soft_cap_alerts!
+          return unless soft_enforcement?
+
+          check_cost_alerts!
+          check_token_alerts!
+          check_execution_alerts!
+        end
+
+        # @return [void]
+        def check_cost_alerts!
+          if effective_daily_limit && daily_cost_spent >= effective_daily_limit
+            AlertManager.notify(:budget_soft_cap, {
+              tenant_id: tenant_id, type: :daily_cost,
+              limit: effective_daily_limit, total: daily_cost_spent
+            })
+          end
+          if effective_monthly_limit && monthly_cost_spent >= effective_monthly_limit
+            AlertManager.notify(:budget_soft_cap, {
+              tenant_id: tenant_id, type: :monthly_cost,
+              limit: effective_monthly_limit, total: monthly_cost_spent
+            })
+          end
+        end
+
+        # @return [void]
+        def check_token_alerts!
+          if effective_daily_token_limit && daily_tokens_used >= effective_daily_token_limit
+            AlertManager.notify(:token_soft_cap, {
+              tenant_id: tenant_id, type: :daily_tokens,
+              limit: effective_daily_token_limit, total: daily_tokens_used
+            })
+          end
+          if effective_monthly_token_limit && monthly_tokens_used >= effective_monthly_token_limit
+            AlertManager.notify(:token_soft_cap, {
+              tenant_id: tenant_id, type: :monthly_tokens,
+              limit: effective_monthly_token_limit, total: monthly_tokens_used
+            })
+          end
+        end
+
+        # @return [void]
+        def check_execution_alerts!
+          if effective_daily_execution_limit && daily_executions_count >= effective_daily_execution_limit
+            AlertManager.notify(:budget_soft_cap, {
+              tenant_id: tenant_id, type: :daily_executions,
+              limit: effective_daily_execution_limit, total: daily_executions_count
+            })
+          end
+          if effective_monthly_execution_limit && monthly_executions_count >= effective_monthly_execution_limit
+            AlertManager.notify(:budget_soft_cap, {
+              tenant_id: tenant_id, type: :monthly_executions,
+              limit: effective_monthly_execution_limit, total: monthly_executions_count
+            })
+          end
+        end
+      end
+    end
+  end
+end