ruby_llm-agents 3.0.0 → 3.2.0

data/lib/ruby_llm/agents/pipeline/middleware/instrumentation.rb

@@ -52,10 +52,10 @@ module RubyLLM
               begin
                 complete_execution(execution, context, status: "success")
                 status_update_completed = true
-              rescue StandardError
+              rescue
                 # Let ensure block handle via mark_execution_failed!
               end
-            rescue StandardError => e
+            rescue => e
               context.completed_at = Time.current
               context.error = e
               raised_exception = e
@@ -63,7 +63,7 @@ module RubyLLM
               begin
                 complete_execution(execution, context, status: determine_error_status(e))
                 status_update_completed = true
-              rescue StandardError
+              rescue
                 # Let ensure block handle via mark_execution_failed!
               end
 
@@ -100,7 +100,7 @@ module RubyLLM
             end
 
             execution
-          rescue StandardError => e
+          rescue => e
             error("Failed to create running execution record: #{e.message}")
             nil
           end
@@ -131,7 +131,7 @@ module RubyLLM
 
             # Save detail data (prompts, responses, tool calls, etc.)
             save_execution_details(execution, context, status)
-          rescue StandardError => e
+          rescue => e
             error("Failed to complete execution record: #{e.message}")
             raise # Re-raise for ensure block to handle via mark_execution_failed!
           end
@@ -160,16 +160,16 @@ module RubyLLM
 
             # Store error_message in detail table (best-effort)
             begin
-              detail_attrs = { error_message: error_message }
+              detail_attrs = {error_message: error_message}
               if execution.detail
                 execution.detail.update_columns(detail_attrs)
               else
                 RubyLLM::Agents::ExecutionDetail.create!(detail_attrs.merge(execution_id: execution.id))
               end
-            rescue StandardError
+            rescue
               # Non-critical
             end
-          rescue StandardError => e
+          rescue => e
             error("CRITICAL: Failed emergency status update for execution #{execution&.id}: #{e.message}")
           end
 
@@ -223,7 +223,11 @@ module RubyLLM
             }
 
             # Store niche cache key in metadata
-            merged_metadata = context.metadata.dup rescue {}
+            merged_metadata = begin
+              context.metadata.dup
+            rescue
+              {}
+            end
             if context.cached? && context[:cache_key]
               merged_metadata["response_cache_key"] = context[:cache_key]
             end
@@ -253,6 +257,13 @@ module RubyLLM
 
             detail_data = {}
 
+            if global_config.persist_prompts
+              exec_opts = context.options[:options] || {}
+              detail_data[:system_prompt] = exec_opts[:system_prompt]
+              detail_data[:user_prompt] = context.input.to_s.presence
+              detail_data[:assistant_prompt] = exec_opts[:assistant_prefill] if assistant_prompt_column_exists?
+            end
+
             if context.error
               detail_data[:error_message] = truncate_error_message(context.error.message)
             end
@@ -277,7 +288,7 @@ module RubyLLM
             else
               execution.create_detail!(detail_data)
             end
-          rescue StandardError => e
+          rescue => e
             error("Failed to save execution details: #{e.message}")
           end
 
@@ -297,7 +308,7 @@ module RubyLLM
             else
               create_execution_record(data)
             end
-          rescue StandardError => e
+          rescue => e
             error("Failed to record execution: #{e.message}")
           end
 
@@ -307,7 +318,11 @@ module RubyLLM
           # @param status [String] "success" or "error"
           # @return [Hash] Execution data
           def build_execution_data(context, status)
-            merged_metadata = context.metadata.dup rescue {}
+            merged_metadata = begin
+              context.metadata.dup
+            rescue
+              {}
+            end
             if context.cached? && context[:cache_key]
               merged_metadata["response_cache_key"] = context[:cache_key]
             end
@@ -348,7 +363,13 @@ module RubyLLM
             end
 
             # Store detail data for separate creation
-            detail_data = { parameters: sanitize_parameters(context) }
+            detail_data = {parameters: sanitize_parameters(context)}
+            if global_config.persist_prompts
+              exec_opts = context.options[:options] || {}
+              detail_data[:system_prompt] = exec_opts[:system_prompt]
+              detail_data[:user_prompt] = context.input.to_s.presence
+              detail_data[:assistant_prompt] = exec_opts[:assistant_prefill] if assistant_prompt_column_exists?
+            end
             detail_data[:error_message] = truncate_error_message(context.error.message) if context.error
             detail_data[:tool_calls] = context[:tool_calls] if context[:tool_calls].present?
             detail_data[:attempts] = context[:reliability_attempts] if context[:reliability_attempts].present?
@@ -383,7 +404,11 @@ module RubyLLM
           def sanitize_parameters(context)
             return {} unless context.agent_instance.respond_to?(:options, true)
 
-            params = context.agent_instance.send(:options) rescue {}
+            params = begin
+              context.agent_instance.send(:options)
+            rescue
+              {}
+            end
             params = params.dup
             params.transform_keys!(&:to_s)
 
@@ -408,7 +433,7 @@ module RubyLLM
             return "" if message.nil?
 
             message.to_s.truncate(1000)
-          rescue StandardError
+          rescue
             message.to_s[0, 1000]
           end
 
@@ -423,7 +448,7 @@ module RubyLLM
             return nil if content.nil?
 
             # Build response hash similar to core instrumentation
-            response_data = { content: content }
+            response_data = {content: content}
 
             # Add model_id if available
             response_data[:model_id] = context.model_used if context.model_used
@@ -433,7 +458,7 @@ module RubyLLM
             response_data[:output_tokens] = context.output_tokens if context.output_tokens
 
             response_data
-          rescue StandardError => e
+          rescue => e
             error("Failed to serialize response: #{e.message}")
             nil
           end
@@ -451,7 +476,7 @@ module RubyLLM
           def create_execution_record(data)
             detail_data = data.delete(:_detail_data)
             execution = Execution.create!(data)
-            if detail_data && detail_data.values.any? { |v| v.present? && v != {} && v != [] }
+            if detail_data&.values&.any? { |v| v.present? && v != {} && v != [] }
               execution.create_detail!(detail_data)
             end
             execution
@@ -474,7 +499,7 @@ module RubyLLM
             else
               cfg.track_executions
             end
-          rescue StandardError
+          rescue
             false
           end
 
@@ -483,7 +508,7 @@ module RubyLLM
           # @return [Boolean]
           def track_cache_hits?
             global_config.respond_to?(:track_cache_hits) && global_config.track_cache_hits
-          rescue StandardError
+          rescue
             false
           end
 
@@ -492,10 +517,26 @@ module RubyLLM
           # @return [Boolean]
           def async_logging?
             global_config.async_logging && defined?(Infrastructure::ExecutionLoggerJob)
-          rescue StandardError
+          rescue
             false
           end
 
+          # Checks if the assistant_prompt column exists on execution_details
+          #
+          # Memoized to avoid repeated schema queries.
+          #
+          # @return [Boolean]
+          def assistant_prompt_column_exists?
+            return @_assistant_prompt_column_exists if defined?(@_assistant_prompt_column_exists)
+
+            @_assistant_prompt_column_exists = begin
+              defined?(RubyLLM::Agents::ExecutionDetail) &&
+                RubyLLM::Agents::ExecutionDetail.column_names.include?("assistant_prompt")
+            rescue
+              false
+            end
+          end
+
           # Returns whether the Execution model is available
           #
           # @return [Boolean]

data/lib/ruby_llm/agents/pipeline/middleware/reliability.rb

@@ -172,8 +172,7 @@ module RubyLLM
                 tracker.complete_attempt(attempt, success: true, response: context.output)
 
                 return context
-
-              rescue StandardError => e
+              rescue => e
                 context.error = e
                 breaker&.record_failure!
                 tracker.complete_attempt(attempt, success: false, error: e)
@@ -305,7 +304,7 @@ module RubyLLM
             else
               sleep(seconds)
             end
-          rescue StandardError
+          rescue
             # Fall back to regular sleep if async detection fails
             sleep(seconds)
           end

data/lib/ruby_llm/agents/pipeline/middleware/tenant.rb

@@ -42,6 +42,7 @@ module RubyLLM
           # @return [Context] The context with tenant fields populated
           def call(context)
             resolve_tenant!(context)
+            ensure_tenant_record!(context)
             apply_api_configuration!(context)
             @app.call(context)
           end
@@ -78,12 +79,89 @@ module RubyLLM
                 context.tenant_config = extract_tenant_config(tenant_value)
               else
                 raise ArgumentError,
-                      "tenant must respond to :llm_tenant_id (use llm_tenant DSL), " \
-                      "or be a Hash with :id key, got #{tenant_value.class}"
+                  "tenant must respond to :llm_tenant_id (use llm_tenant DSL), " \
+                  "or be a Hash with :id key, got #{tenant_value.class}"
               end
             end
           end
 
+          # Ensures a Tenant record exists in the database for the resolved tenant.
+          #
+          # When a host model (e.g., Organization) with LLMTenant is passed as
+          # tenant: to an agent, the after_create callback only fires for new records.
+          # Pre-existing records won't have a Tenant row yet. This method auto-creates
+          # it on first use so budget tracking and the dashboard work correctly.
+          #
+          # @param context [Context] The execution context
+          def ensure_tenant_record!(context)
+            return unless context.tenant_id.present?
+            return unless tenant_table_exists?
+
+            tenant_object = context.tenant_object
+
+            # Only auto-create when the tenant object uses the LLMTenant concern
+            if tenant_object.respond_to?(:llm_tenant_id) && tenant_object.is_a?(::ActiveRecord::Base)
+              ensure_tenant_for_model!(tenant_object)
+            else
+              # For hash-based or string tenants, ensure a minimal record exists
+              RubyLLM::Agents::Tenant.find_or_create_by!(tenant_id: context.tenant_id)
+            end
+          rescue => e
+            # Don't fail the execution if tenant record creation fails
+            log_tenant_warning("ensure tenant record", e)
+          end
+
+          # Creates a Tenant record linked to the host model if one doesn't exist
+          #
+          # @param tenant_object [ActiveRecord::Base] The host model with LLMTenant
+          def ensure_tenant_for_model!(tenant_object)
+            # Check polymorphic link first, then tenant_id
+            existing = RubyLLM::Agents::Tenant.find_by(tenant_record: tenant_object) ||
+              RubyLLM::Agents::Tenant.find_by(tenant_id: tenant_object.llm_tenant_id)
+            return if existing
+
+            options = tenant_object.class.try(:llm_tenant_options) || {}
+            limits = options[:limits] || {}
+            name_method = options[:name] || :to_s
+
+            RubyLLM::Agents::Tenant.create!(
+              tenant_id: tenant_object.llm_tenant_id,
+              name: tenant_object.send(name_method).to_s,
+              tenant_record: tenant_object,
+              daily_limit: limits[:daily_cost],
+              monthly_limit: limits[:monthly_cost],
+              daily_token_limit: limits[:daily_tokens],
+              monthly_token_limit: limits[:monthly_tokens],
+              daily_execution_limit: limits[:daily_executions],
+              monthly_execution_limit: limits[:monthly_executions],
+              enforcement: options[:enforcement]&.to_s || "soft",
+              inherit_global_defaults: options.fetch(:inherit_global, true)
+            )
+          end
+
+          # Checks if the tenants table exists (memoized)
+          #
+          # @return [Boolean]
+          def tenant_table_exists?
+            return @tenant_table_exists if defined?(@tenant_table_exists)
+
+            @tenant_table_exists = ::ActiveRecord::Base.connection.table_exists?(:ruby_llm_agents_tenants)
+          rescue
+            @tenant_table_exists = false
+          end
+
+          # Logs a warning without failing the execution
+          #
+          # @param action [String] What was being attempted
+          # @param error [StandardError] The error
+          def log_tenant_warning(action, error)
+            return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+            Rails.logger.warn(
+              "[RubyLLM::Agents] Failed to #{action}: #{error.message}"
+            )
+          end
+
           # Applies API configuration to RubyLLM based on resolved tenant
           #
           # @param context [Context] The execution context
@@ -103,7 +181,7 @@ module RubyLLM
             return if api_keys.blank?
 
             apply_api_keys_to_ruby_llm(api_keys)
-          rescue StandardError => e
+          rescue => e
             # Log but don't fail if API key extraction fails
             warn_api_key_error("tenant object", e)
           end
@@ -150,7 +228,7 @@ module RubyLLM
             return nil unless tenant.respond_to?(:llm_config)
 
             tenant.llm_config
-          rescue StandardError
+          rescue
             nil
           end
         end

data/lib/ruby_llm/agents/results/background_removal_result.rb

@@ -16,9 +16,9 @@ module RubyLLM
     #
     class BackgroundRemovalResult
       attr_reader :foreground, :mask, :source_image, :model_id, :output_format,
-                  :alpha_matting, :refine_edges,
-                  :started_at, :completed_at, :tenant_id, :remover_class,
-                  :error_class, :error_message
+        :alpha_matting, :refine_edges,
+        :started_at, :completed_at, :tenant_id, :remover_class,
+        :error_class, :error_message
 
       # Initialize a new result
       #
@@ -36,8 +36,8 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(foreground:, mask:, source_image:, model_id:, output_format:,
-                     alpha_matting:, refine_edges:, started_at:, completed_at:,
-                     tenant_id:, remover_class:, error_class: nil, error_message: nil)
+        alpha_matting:, refine_edges:, started_at:, completed_at:,
+        tenant_id:, remover_class:, error_class: nil, error_message: nil)
         @foreground = foreground
         @mask = mask
         @source_image = source_image
@@ -224,7 +224,7 @@ module RubyLLM
     # Lightweight result for cached removals
     class CachedBackgroundRemovalResult
       attr_reader :url, :data, :mask_url, :mask_data, :mime_type, :model_id,
-                  :output_format, :total_cost, :cached_at
+        :output_format, :total_cost, :cached_at
 
       def initialize(data)
         @url = data[:url]

data/lib/ruby_llm/agents/results/embedding_result.rb

@@ -156,13 +156,13 @@ module RubyLLM
         return nil if v1.nil?
 
         v2 = case other
-             when EmbeddingResult
-               other.vector
-             when Array
-               other
-             else
-               raise ArgumentError, "other must be EmbeddingResult or Array, got #{other.class}"
-             end
+        when EmbeddingResult
+          other.vector
+        when Array
+          other
+        else
+          raise ArgumentError, "other must be EmbeddingResult or Array, got #{other.class}"
+        end
 
         return nil if v2.nil?
 
@@ -183,17 +183,17 @@ module RubyLLM
 
         similarities = others.each_with_index.map do |other, idx|
           v2 = case other
-               when EmbeddingResult
-                 other.vector
-               when Array
-                 other
-               else
-                 next nil
-               end
+          when EmbeddingResult
+            other.vector
+          when Array
+            other
+          else
+            next nil
+          end
 
           next nil if v2.nil?
 
-          { index: idx, similarity: cosine_similarity(v1, v2) }
+          {index: idx, similarity: cosine_similarity(v1, v2)}
         end.compact
 
         similarities.sort_by { |s| -s[:similarity] }.first(limit)

data/lib/ruby_llm/agents/results/image_analysis_result.rb

@@ -18,9 +18,9 @@ module RubyLLM
     #
     class ImageAnalysisResult
       attr_reader :image, :model_id, :analysis_type,
-                  :caption, :description, :tags, :objects, :colors, :text,
-                  :raw_response, :started_at, :completed_at, :tenant_id, :analyzer_class,
-                  :error_class, :error_message
+        :caption, :description, :tags, :objects, :colors, :text,
+        :raw_response, :started_at, :completed_at, :tenant_id, :analyzer_class,
+        :error_class, :error_message
 
       # Initialize a new result
       #
@@ -41,8 +41,8 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(image:, model_id:, analysis_type:, caption:, description:, tags:,
-                     objects:, colors:, text:, raw_response:, started_at:, completed_at:,
-                     tenant_id:, analyzer_class:, error_class: nil, error_message: nil)
+        objects:, colors:, text:, raw_response:, started_at:, completed_at:,
+        tenant_id:, analyzer_class:, error_class: nil, error_message: nil)
         @image = image
         @model_id = model_id
         @analysis_type = analysis_type
@@ -235,8 +235,8 @@ module RubyLLM
     # Lightweight result for cached analyses
     class CachedImageAnalysisResult
       attr_reader :image, :model_id, :analysis_type,
-                  :caption, :description, :tags, :objects, :colors, :text,
-                  :total_cost, :cached_at
+        :caption, :description, :tags, :objects, :colors, :text,
+        :total_cost, :cached_at
 
       def initialize(data)
         @image = data[:image]

data/lib/ruby_llm/agents/results/image_edit_result.rb

@@ -18,8 +18,8 @@ module RubyLLM
     #
     class ImageEditResult
       attr_reader :images, :source_image, :mask, :prompt, :model_id, :size,
-                  :started_at, :completed_at, :tenant_id, :editor_class,
-                  :error_class, :error_message
+        :started_at, :completed_at, :tenant_id, :editor_class,
+        :error_class, :error_message
 
       # Initialize a new result
       #
@@ -36,8 +36,8 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(images:, source_image:, mask:, prompt:, model_id:, size:,
-                     started_at:, completed_at:, tenant_id:, editor_class:,
-                     error_class: nil, error_message: nil)
+        started_at:, completed_at:, tenant_id:, editor_class:,
+        error_class: nil, error_message: nil)
         @images = images
         @source_image = source_image
         @mask = mask

data/lib/ruby_llm/agents/results/image_generation_result.rb

@@ -21,8 +21,8 @@ module RubyLLM
     #
     class ImageGenerationResult
       attr_reader :images, :prompt, :model_id, :size, :quality, :style,
-                  :started_at, :completed_at, :tenant_id, :generator_class,
-                  :error_class, :error_message
+        :started_at, :completed_at, :tenant_id, :generator_class,
+        :error_class, :error_message
 
       # Initialize a new result
       #
@@ -39,8 +39,8 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(images:, prompt:, model_id:, size:, quality:, style:,
-                     started_at:, completed_at:, tenant_id:, generator_class:,
-                     error_class: nil, error_message: nil)
+        started_at:, completed_at:, tenant_id:, generator_class:,
+        error_class: nil, error_message: nil)
         @images = images
         @prompt = prompt
         @model_id = model_id
@@ -294,7 +294,7 @@ module RubyLLM
     #
     class CachedImageGenerationResult
       attr_reader :urls, :datas, :mime_type, :revised_prompts, :model_id,
-                  :total_cost, :cached_at
+        :total_cost, :cached_at
 
       def initialize(data)
         @urls = data[:urls] || []

data/lib/ruby_llm/agents/results/image_pipeline_result.rb

@@ -22,7 +22,7 @@ module RubyLLM
     #
     class ImagePipelineResult
       attr_reader :step_results, :started_at, :completed_at, :tenant_id,
-                  :pipeline_class, :context, :error_class, :error_message
+        :pipeline_class, :context, :error_class, :error_message
 
       # Initialize a new pipeline result
       #
@@ -35,7 +35,7 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(step_results:, started_at:, completed_at:, tenant_id:,
-                     pipeline_class:, context:, error_class: nil, error_message: nil)
+        pipeline_class:, context:, error_class: nil, error_message: nil)
         @step_results = step_results
         @started_at = started_at
         @completed_at = completed_at
@@ -100,7 +100,7 @@ module RubyLLM
         step_data&.dig(:result)
       end
 
-      alias [] step
+      alias_method :[], :step
 
       # Get step names
       #
@@ -378,7 +378,7 @@ module RubyLLM
         step_data&.dig(:cached_result)
       end
 
-      alias [] step
+      alias_method :[], :step
 
       def final_image
         # Find last non-analyzer step

data/lib/ruby_llm/agents/results/image_transform_result.rb

@@ -18,8 +18,8 @@ module RubyLLM
     #
     class ImageTransformResult
       attr_reader :images, :source_image, :prompt, :model_id, :size, :strength,
-                  :started_at, :completed_at, :tenant_id, :transformer_class,
-                  :error_class, :error_message
+        :started_at, :completed_at, :tenant_id, :transformer_class,
+        :error_class, :error_message
 
       # Initialize a new result
       #
@@ -36,8 +36,8 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(images:, source_image:, prompt:, model_id:, size:, strength:,
-                     started_at:, completed_at:, tenant_id:, transformer_class:,
-                     error_class: nil, error_message: nil)
+        started_at:, completed_at:, tenant_id:, transformer_class:,
+        error_class: nil, error_message: nil)
         @images = images
         @source_image = source_image
         @prompt = prompt

data/lib/ruby_llm/agents/results/image_upscale_result.rb

@@ -16,8 +16,8 @@ module RubyLLM
     #
     class ImageUpscaleResult
       attr_reader :image, :source_image, :model_id, :scale, :output_size, :face_enhance,
-                  :started_at, :completed_at, :tenant_id, :upscaler_class,
-                  :error_class, :error_message
+        :started_at, :completed_at, :tenant_id, :upscaler_class,
+        :error_class, :error_message
 
       # Initialize a new result
       #
@@ -34,8 +34,8 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(image:, source_image:, model_id:, scale:, output_size:, face_enhance:,
-                     started_at:, completed_at:, tenant_id:, upscaler_class:,
-                     error_class: nil, error_message: nil)
+        started_at:, completed_at:, tenant_id:, upscaler_class:,
+        error_class: nil, error_message: nil)
         @image = image
         @source_image = source_image
         @model_id = model_id
@@ -198,7 +198,7 @@ module RubyLLM
     # Lightweight result for cached upscales
     class CachedImageUpscaleResult
       attr_reader :url, :data, :mime_type, :model_id, :scale, :output_size,
-                  :total_cost, :cached_at
+        :total_cost, :cached_at
 
       def initialize(data)
         @url = data[:url]

data/lib/ruby_llm/agents/results/image_variation_result.rb

@@ -15,8 +15,8 @@ module RubyLLM
     #
     class ImageVariationResult
       attr_reader :images, :source_image, :model_id, :size, :variation_strength,
-                  :started_at, :completed_at, :tenant_id, :variator_class,
-                  :error_class, :error_message
+        :started_at, :completed_at, :tenant_id, :variator_class,
+        :error_class, :error_message
 
       # Initialize a new result
       #
@@ -32,8 +32,8 @@ module RubyLLM
       # @param error_class [String, nil] Error class name if failed
       # @param error_message [String, nil] Error message if failed
       def initialize(images:, source_image:, model_id:, size:, variation_strength:,
-                     started_at:, completed_at:, tenant_id:, variator_class:,
-                     error_class: nil, error_message: nil)
+        started_at:, completed_at:, tenant_id:, variator_class:,
+        error_class: nil, error_message: nil)
         @images = images
         @source_image = source_image
         @model_id = model_id

data/lib/ruby_llm/agents/results/transcription_result.rb

@@ -322,7 +322,7 @@ module RubyLLM
         return nil unless segments.present?
 
         segments.find do |segment|
-          timestamp >= segment[:start] && timestamp <= segment[:end]
+          timestamp.between?(segment[:start], segment[:end])
         end
       end