ruby_llm-agents 3.12.0 → 3.14.0

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

@@ -48,7 +48,7 @@ module RubyLLM
               raised_exception = nil
 
               begin
-                @app.call(context)
+                capture_llm_requests(context) { @app.call(context) }
                 context.completed_at = Time.current
 
                 begin
@@ -84,6 +84,55 @@ module RubyLLM
 
           private
 
+          # Fiber-local stack of in-flight request accumulators, innermost last.
+          REQUEST_CAPTURE_STACK = :ruby_llm_agents_request_capture
+
+          # Captures real HTTP-level provider latency for the LLM call(s) made
+          # while running the rest of the pipeline.
+          #
+          # ruby_llm 1.16 emits a "request.ruby_llm" event per HTTP request and
+          # its Railtie wires ActiveSupport::Notifications as the instrumenter
+          # in Rails, so we subscribe for the duration of the downstream call
+          # and accumulate provider time and request count (retries/fallbacks
+          # add up). This is distinct from the total pipeline duration, which
+          # also includes middleware and tool execution. The values are stored
+          # in context metadata and persisted with the execution.
+          #
+          # AS::Notifications subscriptions are process-global, so a naive
+          # subscriber would also see events from other executions running
+          # concurrently (other threads) or nested inside this one (agent-as-
+          # tool). To attribute each request to exactly one execution, we keep
+          # a fiber-local stack of accumulators and only credit the innermost
+          # one on the thread that actually emitted the event — the callback
+          # runs synchronously on the emitting thread, so its top-of-stack is
+          # the execution whose LLM call fired.
+          #
+          # @param context [Context] The execution context
+          # @return [Object] The downstream call's return value
+          def capture_llm_requests(context)
+            return yield unless defined?(ActiveSupport::Notifications)
+
+            accumulator = {ms: 0.0, count: 0}
+            stack = (Thread.current[REQUEST_CAPTURE_STACK] ||= [])
+            stack.push(accumulator)
+
+            callback = lambda do |_name, started, finished, _id, _payload|
+              top = Thread.current[REQUEST_CAPTURE_STACK]&.last
+              next unless top.equal?(accumulator)
+
+              accumulator[:ms] += (finished - started) * 1000.0
+              accumulator[:count] += 1
+            end
+
+            ActiveSupport::Notifications.subscribed(callback, "request.ruby_llm") { yield }
+          ensure
+            stack&.pop
+            if accumulator && accumulator[:count].positive?
+              context[:llm_request_ms] = accumulator[:ms].round
+              context[:llm_request_count] = accumulator[:count]
+            end
+          end
+
           # Creates initial execution record with 'running' status
           #
           # Creates the record synchronously so it appears on the dashboard immediately.
@@ -339,6 +388,8 @@ module RubyLLM
               cache_hit: context.cached?,
               input_tokens: context.input_tokens || 0,
               output_tokens: context.output_tokens || 0,
+              input_cost: context.input_cost,
+              output_cost: context.output_cost,
               total_cost: context.total_cost || 0,
               attempts_count: context.attempts_made,
               chosen_model_id: context.model_used,

data/lib/ruby_llm/agents/rails/engine.rb

@@ -33,6 +33,7 @@ module RubyLLM
       # @api private
       config.to_prepare do
         require_relative "../infrastructure/execution_logger_job"
+        require_relative "../infrastructure/retention_job"
         require_relative "../core/instrumentation"
         require_relative "../core/base"
 
@@ -153,18 +154,33 @@ module RubyLLM
           end
           helper_method :tenant_scoped_executions
 
-          # Returns list of available tenants for filtering dropdown
+          # Returns the list of tenants for the dropdown as label/value pairs.
           #
-          # @return [Array<String>] Unique tenant IDs from executions
+          # Tenants that have a matching row in ruby_llm_agents_tenants get their
+          # configured name; legacy or string-only tenants fall back to the raw
+          # tenant_id so nothing disappears from the filter.
+          #
+          # Two queries total — one DISTINCT pluck on executions, one pluck on
+          # tenants — regardless of how many tenant_ids exist.
+          #
+          # @return [Array<Hash>] Entries shaped as { value:, label: }
           # @api public
           def available_tenants
             return @available_tenants if defined?(@available_tenants)
 
-            @available_tenants = RubyLLM::Agents::Execution
+            tenant_ids = RubyLLM::Agents::Execution
               .where.not(tenant_id: nil)
               .distinct
               .pluck(:tenant_id)
-              .sort
+
+            names_by_id = RubyLLM::Agents::Tenant
+              .where(tenant_id: tenant_ids)
+              .pluck(:tenant_id, :name)
+              .to_h
+
+            @available_tenants = tenant_ids
+              .map { |id| {value: id, label: (names_by_id[id].presence || id).to_s} }
+              .sort_by { |t| t[:label].downcase }
           end
           helper_method :available_tenants
         end)

data/lib/ruby_llm/agents/routing.rb

@@ -115,6 +115,15 @@ module RubyLLM
         @ask_message || options[:message] || super
       end
 
+      # Override call to capture the caller's stream block so it can be
+      # forwarded to the delegated agent. Without this, chunks from the
+      # delegated agent are swallowed because build_result has no access
+      # to the original block.
+      def call(&block)
+        @delegation_stream_block = block
+        super
+      end
+
       # Override process_response to parse the route from LLM output.
       def process_response(response)
         raw = response.content.to_s.strip.downcase.gsub(/[^a-z0-9_]/, "")
@@ -131,25 +140,39 @@ module RubyLLM
       end
 
       # Override build_result to return a RoutingResult.
-      # Auto-delegates to the mapped agent when the route has an `agent:` mapping.
+      # Auto-delegates to the mapped agent when the route has an `agent:` mapping,
+      # unless the caller opts out with `auto_delegate: false`.
       def build_result(content, response, context)
         base = super
 
-        # Auto-delegate to the mapped agent
         agent_class = content[:agent_class]
-        if agent_class
-          content[:delegated_result] = agent_class.call(**delegation_params)
+        if agent_class && auto_delegate?
+          content[:delegated_result] = if @delegation_stream_block
+            agent_class.call(**delegation_params, &@delegation_stream_block)
+          else
+            agent_class.call(**delegation_params)
+          end
         end
 
         RoutingResult.new(base_result: base, route_data: content)
       end
 
+      # Whether auto-delegation to the mapped agent is enabled for this call.
+      # Defaults to true. Pass `auto_delegate: false` to receive a
+      # classification-only RoutingResult with `delegated? == false` and
+      # `agent_class` set so the caller can invoke it manually.
+      #
+      # @return [Boolean]
+      def auto_delegate?
+        @options.fetch(:auto_delegate, true)
+      end
+
       # Builds params to forward to the delegated agent.
       # Forwards original message and custom params, excludes routing internals.
       #
       # @return [Hash] Params for the delegated agent
       def delegation_params
-        forward = @options.except(:dry_run, :skip_cache, :debug, :stream_events)
+        forward = @options.except(:dry_run, :skip_cache, :debug, :stream_events, :auto_delegate)
         forward[:_parent_execution_id] = @parent_execution_id if @parent_execution_id
         forward[:_root_execution_id] = @root_execution_id if @root_execution_id
         forward

data/lib/ruby_llm/agents.rb

@@ -96,6 +96,7 @@ if defined?(Rails)
   require_relative "agents/core/inflections"
   require_relative "agents/core/instrumentation"
   require_relative "agents/infrastructure/execution_logger_job"
+  require_relative "agents/infrastructure/retention_job"
 end
 require_relative "agents/rails/engine" if defined?(Rails::Engine)
 

data/lib/tasks/ruby_llm_agents.rake

@@ -7,6 +7,13 @@ namespace :ruby_llm_agents do
     RubyLlmAgents::DoctorGenerator.start([])
   end
 
+  desc "Run the retention job synchronously (soft + hard purges per configuration)"
+  task purge: :environment do
+    result = RubyLLM::Agents::RetentionJob.new.perform
+    puts "Soft purged: #{result[:soft_purged]} executions (details destroyed)"
+    puts "Hard purged: #{result[:hard_purged]} executions (rows destroyed)"
+  end
+
   desc "Rename an agent type in execution records. Usage: rake ruby_llm_agents:rename_agent FROM=OldName TO=NewName [DRY_RUN=1]"
   task rename_agent: :environment do
     from = ENV["FROM"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-agents
 version: !ruby/object:Gem::Version
-  version: 3.12.0
+  version: 3.14.0
 platform: ruby
 authors:
 - adham90
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.12.0
+        version: 1.16.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.12.0
+        version: 1.16.0
 - !ruby/object:Gem::Dependency
   name: csv
   requirement: !ruby/object:Gem::Requirement
@@ -290,6 +290,7 @@ files:
 - lib/ruby_llm/agents/infrastructure/circuit_breaker.rb
 - lib/ruby_llm/agents/infrastructure/execution_logger_job.rb
 - lib/ruby_llm/agents/infrastructure/reliability.rb
+- lib/ruby_llm/agents/infrastructure/retention_job.rb
 - lib/ruby_llm/agents/pipeline.rb
 - lib/ruby_llm/agents/pipeline/builder.rb
 - lib/ruby_llm/agents/pipeline/context.rb