ruby_llm-agents 1.3.4 → 2.1.0

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

@@ -19,13 +19,10 @@ module RubyLLM
         "dashboard/index" => "Dashboard",
         "agents/index" => "Agent-DSL",
         "agents/show" => "Agent-DSL",
-        "workflows/index" => "Workflows",
-        "workflows/show" => "Workflows",
         "executions/index" => "Execution-Tracking",
         "executions/show" => "Execution-Tracking",
         "tenants/index" => "Multi-Tenancy",
-        "system_config/show" => "Configuration",
-        "api_configurations/show" => "Configuration"
+        "system_config/show" => "Configuration"
       }.freeze
 
       # Returns the documentation URL for the current page or a specific page key
@@ -59,27 +56,11 @@ module RubyLLM
 
       # Returns the URL for "All Tenants" (clears tenant filter)
       #
-      # Handles two scenarios:
-      # 1. Query param routes - removes tenant_id from query params
-      # 2. Path-based tenant routes - navigates to equivalent global route
+      # Removes tenant_id from query params to show unfiltered results.
       #
       # @return [String] URL without tenant filtering
       def all_tenants_url
-        # Map tenant-specific path routes to their global equivalents
-        tenant_route_mappings = {
-          "tenant" => ruby_llm_agents.api_configuration_path,
-          "edit_tenant" => ruby_llm_agents.edit_api_configuration_path
-        }
-
-        # Check if current action has a global equivalent
-        if tenant_route_mappings.key?(action_name)
-          base_path = tenant_route_mappings[action_name]
-          query = request.query_parameters.except("tenant_id")
-          query.any? ? "#{base_path}?#{query.to_query}" : base_path
-        else
-          # For query param routes, just remove tenant_id
-          url_for(request.query_parameters.except("tenant_id"))
-        end
+        url_for(request.query_parameters.except("tenant_id"))
       end
 
       # Formats large numbers with human-readable suffixes (K, M, B)
@@ -121,7 +102,7 @@ module RubyLLM
       # @return [ActiveSupport::SafeBuffer] HTML badge element
       def render_enabled_badge(enabled)
         if enabled
-          '<span class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-green-100 dark:bg-green-900/50 text-green-700 dark:text-green-300">Enabled</span>'.html_safe
+          '<span class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-green-100 dark:bg-green-500/20 text-green-700 dark:text-green-300">Enabled</span>'.html_safe
         else
           '<span class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400">Disabled</span>'.html_safe
         end
@@ -133,7 +114,7 @@ module RubyLLM
       # @return [ActiveSupport::SafeBuffer] HTML badge element
       def render_configured_badge(configured)
         if configured
-          '<span class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-green-100 dark:bg-green-900/50 text-green-700 dark:text-green-300">Configured</span>'.html_safe
+          '<span class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-green-100 dark:bg-green-500/20 text-green-700 dark:text-green-300">Configured</span>'.html_safe
         else
           '<span class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400">Not configured</span>'.html_safe
         end
@@ -254,7 +235,7 @@ module RubyLLM
                         end
 
         if is_improvement
-          content_tag(:span, class: "inline-flex items-center gap-1 px-2 py-0.5 text-xs font-medium text-green-700 dark:text-green-300 bg-green-100 dark:bg-green-900/50 rounded-full") do
+          content_tag(:span, class: "inline-flex items-center gap-1 px-2 py-0.5 text-xs font-medium text-green-700 dark:text-green-300 bg-green-100 dark:bg-green-500/20 rounded-full") do
             safe_join([
               content_tag(:svg, class: "w-3 h-3", 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 10l7-7m0 0l7 7m-7-7v18")
@@ -263,7 +244,7 @@ module RubyLLM
             ])
           end
         elsif is_regression
-          content_tag(:span, class: "inline-flex items-center gap-1 px-2 py-0.5 text-xs font-medium text-red-700 dark:text-red-300 bg-red-100 dark:bg-red-900/50 rounded-full") do
+          content_tag(:span, class: "inline-flex items-center gap-1 px-2 py-0.5 text-xs font-medium text-red-700 dark:text-red-300 bg-red-100 dark:bg-red-500/20 rounded-full") do
             safe_join([
               content_tag(:svg, class: "w-3 h-3", 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 14l-7 7m0 0l-7-7m7 7V3")
@@ -306,31 +287,16 @@ module RubyLLM
 
       # Returns human-readable display name for time range
       #
-      # @param range [String] Range parameter (today, 7d, 30d, 60d, 90d, or custom YYYY-MM-DD_YYYY-MM-DD)
+      # @param range [String] Range parameter (today, 7d, 30d)
       # @return [String] Human-readable range name
       # @example
-      #   range_display_name("7d") #=> "Last 7 Days"
-      #   range_display_name("2024-01-01_2024-01-15") #=> "Jan 1 - Jan 15"
+      #   range_display_name("7d") #=> "7 Days"
       def range_display_name(range)
         case range
         when "today" then "Today"
-        when "7d" then "Last 7 Days"
-        when "30d" then "Last 30 Days"
-        when "60d" then "Last 60 Days"
-        when "90d" then "Last 90 Days"
-        else
-          if range&.include?("_")
-            from_str, to_str = range.split("_")
-            from_date = Date.parse(from_str) rescue nil
-            to_date = Date.parse(to_str) rescue nil
-            if from_date && to_date
-              "#{from_date.strftime('%b %-d')} - #{to_date.strftime('%b %-d')}"
-            else
-              "Custom Range"
-            end
-          else
-            "Today"
-          end
+        when "7d" then "7 Days"
+        when "30d" then "30 Days"
+        else "Today"
         end
       end
 
@@ -391,7 +357,7 @@ module RubyLLM
       # @return [ActiveSupport::SafeBuffer] HTML summary banner
       def comparison_summary_badge(improvements_count, regressions_count, v2_label)
         if improvements_count >= 3 && regressions_count == 0
-          content_tag(:span, class: "inline-flex items-center gap-1 px-3 py-1 text-sm font-medium text-green-700 dark:text-green-300 bg-green-100 dark:bg-green-900/50 rounded-lg") do
+          content_tag(:span, class: "inline-flex items-center gap-1 px-3 py-1 text-sm font-medium text-green-700 dark:text-green-300 bg-green-100 dark:bg-green-500/20 rounded-lg") do
             safe_join([
               content_tag(:svg, class: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24") do
                 content_tag(:path, nil, "stroke-linecap": "round", "stroke-linejoin": "round", "stroke-width": "2", d: "M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z")
@@ -400,7 +366,7 @@ module RubyLLM
             ])
           end
         elsif regressions_count >= 3 && improvements_count == 0
-          content_tag(:span, class: "inline-flex items-center gap-1 px-3 py-1 text-sm font-medium text-red-700 dark:text-red-300 bg-red-100 dark:bg-red-900/50 rounded-lg") do
+          content_tag(:span, class: "inline-flex items-center gap-1 px-3 py-1 text-sm font-medium text-red-700 dark:text-red-300 bg-red-100 dark:bg-red-500/20 rounded-lg") do
             safe_join([
               content_tag(:svg, class: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24") do
                 content_tag(:path, nil, "stroke-linecap": "round", "stroke-linejoin": "round", "stroke-width": "2", d: "M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z")
@@ -409,7 +375,7 @@ module RubyLLM
             ])
           end
         elsif improvements_count > 0 || regressions_count > 0
-          content_tag(:span, class: "inline-flex items-center gap-1 px-3 py-1 text-sm font-medium text-amber-700 dark:text-amber-300 bg-amber-100 dark:bg-amber-900/50 rounded-lg") do
+          content_tag(:span, class: "inline-flex items-center gap-1 px-3 py-1 text-sm font-medium text-amber-700 dark:text-amber-300 bg-amber-100 dark:bg-amber-500/20 rounded-lg") do
             safe_join([
               content_tag(:svg, class: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24") do
                 content_tag(:path, nil, "stroke-linecap": "round", "stroke-linejoin": "round", "stroke-width": "2", d: "M8 7h12m0 0l-4-4m4 4l-4 4m0 6H4m0 0l4 4m-4-4l4-4")
@@ -552,14 +518,14 @@ module RubyLLM
 
             escaped_value = ERB::Util.html_escape(token[:value])
             if is_key
-              result << %(<span class="text-purple-600">#{escaped_value}</span>)
+              result << %(<span class="text-purple-600 dark:text-purple-400">#{escaped_value}</span>)
             else
-              result << %(<span class="text-green-600">#{escaped_value}</span>)
+              result << %(<span class="text-green-600 dark:text-green-400">#{escaped_value}</span>)
             end
           when :number
-            result << %(<span class="text-blue-600">#{token[:value]}</span>)
+            result << %(<span class="text-blue-600 dark:text-blue-400">#{token[:value]}</span>)
           when :boolean
-            result << %(<span class="text-amber-600">#{token[:value]}</span>)
+            result << %(<span class="text-amber-600 dark:text-amber-400">#{token[:value]}</span>)
           when :null
             result << %(<span class="text-gray-400">#{token[:value]}</span>)
           else

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
@@ -323,14 +359,18 @@ module RubyLLM
 
       # Resolves model info for cost calculation
       #
+      # Uses Models.find (local registry lookup) rather than Models.resolve
+      # because cost calculation only needs pricing data, not a provider instance.
+      # Models.resolve requires API keys to instantiate the provider, which may
+      # not be available in background jobs or instrumentation contexts.
+      #
       # @param lookup_model_id [String, nil] The model identifier (defaults to self.model_id)
       # @return [Object, nil] Model info or nil
       def resolve_model_info(lookup_model_id = nil)
         lookup_model_id ||= model_id
         return nil unless lookup_model_id
 
-        model, _provider = RubyLLM::Models.resolve(lookup_model_id)
-        model
+        RubyLLM::Models.find(lookup_model_id)
       rescue StandardError
         nil
       end

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