llm.rb 16.0.0 → 17.0.1

data/lib/llm/context.rb

@@ -39,15 +39,6 @@ module LLM
     include Serializer
     include Deserializer
 
-    TRY_ERRORS = [
-      "LLM::InsufficientQuotaError",
-      "LLM::RateLimitError",
-      "Net::ReadTimeout",
-      "Net::WriteTimeout",
-      "Net::OpenTimeout"
-    ]
-    private_constant :TRY_ERRORS
-
     ##
     # Returns the set of runtime parameters that
     # configure this context and must never be forwarded
@@ -55,7 +46,7 @@ module LLM
     # @api private
     # @return [Array<Symbol>]
     def self.params
-      %w[guard retry_budget concurrency transformer compactor record id]
+      %w[intercept retry_budget concurrency transformer compactor record id]
     end
 
     ##
@@ -80,7 +71,9 @@ module LLM
 
     ##
     # Returns a stable id for this context. It is generated once
-    # on creation and restored with the runtime state on load.
+    # on creation and restored with the runtime state on load - a
+    # context bound to a record takes the record's id instead, when
+    # that id is a UUIDv7 string - and it is always a UUIDv7 string.
     # @return [String]
     attr_reader :id
 
@@ -96,7 +89,10 @@ module LLM
     #   to `:completions`.
     # @option params [String] :model Defaults to the provider's default model
     # @option params [String] :id
-    #   A stable id for the context. Defaults to a UUID.
+    #   A stable id for the context. It must be a UUIDv7 string, and
+    #   anything else raises {LLM::Error}. Defaults to the record's id
+    #   when the context is bound to a record whose id is a UUIDv7, and
+    #   to a generated UUIDv7 otherwise.
     # @option params [Class<LLM::Compactor>, nil] :compactor
     #   A compactor class to use for context compaction. Defaults to
     #   {LLM::Compactor::Null}.
@@ -107,18 +103,18 @@ module LLM
     #   {LLM::Transformer::Null}.
     # @option params [Hash] :transformer_options
     #   Options passed to the transformer's `call` method. Defaults to `{}`.
-    # @option params [Class<LLM::Guard>, nil] :guard
-    #   A guard class to supervise agentic tool execution. Defaults to
-    #   {LLM::Guard::Null}.
-    # @option params [Hash] :guard_options
-    #   Options passed to the guard's `call` method. Defaults to `{}`.
+    # @option params [Class<LLM::Intercept>, nil] :intercept
+    #   Defaults to {LLM::Intercept::Null LLM::Intercept::Null}.
+    # @option params [Hash] :intercept_options
+    #   Options passed to the intercept's `call` method. Defaults to `{}`.
     # @option params [Array<LLM::Function>, nil] :tools Defaults to nil
     # @option params [Array<String>, nil] :skills Defaults to nil
     def initialize(llm, params = {})
       params = {}.merge!(params)
       @llm = llm
-      @id = params.delete(:id) || SecureRandom.uuid_v7
       @record = params.delete(:record)
+      @id = params.delete(:id) || makeid
+      raise LLM::Error, "an id must be a UUIDv7 string" unless LLM::Utils.uuidv7?(@id)
       @mode = params.delete(:mode) || (llm.name == :openai ? :responses : :completions)
       tools = [*params.delete(:tools), *load_skills(params.delete(:skills))]
       @params = {model: llm.default_model, schema: nil}.compact.merge!(params)
@@ -135,9 +131,9 @@ module LLM
         klass: params.delete(:transformer) || LLM::Transformer::Null,
         options: params.delete(:transformer_options) || {}
       }
-      @guard = {
-        klass: params.delete(:guard) || LLM::Guard::Null,
-        options: params.delete(:guard_options) || {}
+      @intercept = {
+        klass: params.delete(:intercept) || LLM::Intercept::Null,
+        options: params.delete(:intercept_options) || {}
       }
       @retry_budget = params.delete(:retry_budget) || 0
     end
@@ -172,20 +168,15 @@ module LLM
     alias_method :compacted?, :compacted
 
     ##
-    # Returns the configured guard class.
-    #
-    # Guards are context-level supervisors for agentic execution. A guard can
-    # inspect the runtime state and decide whether pending tool work should be
-    # blocked before the context keeps looping.
-    #
-    # The guard is stamped onto the functions the context binds, so it runs
-    # whenever a task is spawned — including tool calls queued from a stream
-    # via {LLM::Stream#on_tool_call}. A blocked call yields its in-band
-    # `guard_error` return without executing.
-    #
-    # @return [Class<LLM::Guard>]
-    def guard
-      @guard[:klass]
+    # @see LLM::Intercept
+    # @return [LLM::Intercept]
+    def intercept
+      klass = @intercept[:klass]
+      intercept = Class === klass ? klass.new(llm) : klass
+      intercept.tap do
+        it.instance_variable_set(:@context, self)
+        it.instance_variable_set(:@options, @intercept[:options])
+      end
     end
 
     ##
@@ -230,8 +221,8 @@ module LLM
 
     ##
     # Ask a question and return the content string directly.
-    # Accepts `with:` for file attachments and a block for streaming.
-    # This interface is compatible with RubyLLM's `ask` method.
+    # Accepts `with:` for file attachments and a block for streaming,
+    # the way {#talk} does.
     #
     # @param [String] prompt
     # @param [Hash] options
@@ -268,15 +259,14 @@ module LLM
     # @return [Array<LLM::Function>]
     def pending_functions
       return_ids = returns.map(&:id)
-      guard = @guard[:klass].new(self)
       @messages
         .select(&:assistant?)
         .flat_map do |msg|
-          fns = msg.functions.select { _1.pending? && !return_ids.include?(_1.id) }
+          fns = msg.functions.select { _1.pending? and !return_ids.include?(_1.id) }
           fns.each do |fn|
             fn.tracer = tracer
             fn.model  = msg.model
-            fn.guard  = guard
+            fn.intercept  = intercept
           end
         end.extend(LLM::Function::Array)
     end
@@ -333,8 +323,8 @@ module LLM
       if stream.queue.empty?
         ##
         # Every pending function is spawned as a task that checks its own
-        # guard (stamped on the function) before running. Blocked tasks
-        # yield their guard's return, so all pending calls still close.
+        # intercept (stamped on the function) before running. Blocked tasks
+        # yield their intercept's return, so all pending calls still close.
         tools = except.empty? ? pending_functions : pending_functions - except
         @queue = tools.task(strategy)
         returns = @queue.wait
@@ -597,6 +587,29 @@ module LLM
       [@queue, stream.queue].compact.first
     end
 
+    ##
+    # The id a context is born with.
+    #
+    # The record's id when the context is bound to a record and that id
+    # is a UUIDv7, so that an agent and the row it came from answer the
+    # same name - and a generated UUIDv7 otherwise, which is every
+    # context with no record, every record whose id is an integer or a
+    # slug, and every row that is not saved yet.
+    #
+    # The check is {LLM::Utils.uuidv7?}, which is what
+    # {LLM::Utils.timestamp} reads a time out of as well - rather than a
+    # second opinion about what a UUIDv7 looks like, an id this accepts
+    # is an id `created_at` can answer for.
+    # @api private
+    # @return [Object]
+    def makeid
+      if record
+        LLM::Utils.uuidv7?(record.id) ? record.id : SecureRandom.uuid_v7
+      else
+        SecureRandom.uuid_v7
+      end
+    end
+
     ##
     # Loads skill directories and adapts them into tools.
     # @api private
@@ -641,17 +654,12 @@ module LLM
     def try
       attempts ||= 0
       yield
-    rescue => ex
-      case ex.class.to_s
-      when *TRY_ERRORS
-        raise if attempts >= retry_budget
-        attempts += 1
-        stream.on_retry(ex, attempts)
-        sleep 2.0 * attempts
-        retry
-      else
-        raise(ex)
-      end
+    rescue *llm.retry_errors => ex
+      raise if attempts >= retry_budget
+      attempts += 1
+      stream.on_retry(ex, attempts)
+      sleep 2.0 * attempts
+      retry
     end
 
     # Executes a turn through the Responses API.
@@ -660,7 +668,7 @@ module LLM
       @llm.with(**headers) do
         history = @messages.to_a
         params = @params.merge(params).reject { self.class.params.include?(_1.to_s) }
-        extra = params.slice(:model, :tools).merge!(ctx: self, tracer:, guard: @guard[:klass].new(self))
+        extra = params.slice(:model, :tools).merge!(ctx: self, tracer:, intercept:)
         params[:stream] = LLM::Stream.try(params[:stream], extra:)
         res_id = params[:store] == false ? nil : @messages.find(&:assistant?)&.response&.response_id
         input = res_id ? [] : history
@@ -681,7 +689,7 @@ module LLM
         history = @messages.to_a
         params = params.merge(messages: history)
         params = @params.merge(params).reject { self.class.params.include?(_1.to_s) }
-        extra = params.slice(:model, :tools).merge!(ctx: self, tracer:, guard: @guard[:klass].new(self))
+        extra = params.slice(:model, :tools).merge!(ctx: self, tracer:, intercept:)
         params[:stream] = LLM::Stream.try(params[:stream], extra:)
         messages = transform(prompt, params)
         @stream = params[:stream]

data/lib/llm/function/array.rb

@@ -10,10 +10,11 @@ class LLM::Function
   module Array
     ##
     # Calls all functions in a collection sequentially.
+    #
     # @return [Array<LLM::Function::Return>]
     #  Returns values to be reported back to the LLM.
     def call
-      map(&:call)
+      task(:sequential).wait
     end
 
     ##

data/lib/llm/function/async/group.rb

@@ -42,10 +42,10 @@ module LLM::Function::Async
     alias_method :cancel!, :interrupt!
 
     ##
+    # @see LLM::Function::Group#wait
     # @return [Array<LLM::Function::Return>]
     def wait
-      spawn unless @spawned
-      @tasks.map(&:wait)
+      super
     ensure
       @reactor.stop
     end

data/lib/llm/function/async/task.rb

@@ -68,7 +68,13 @@ module LLM::Function::Async
     # `StandardError`.
     # @return [nil]
     def spawn
-      return if @guarded
+      @span  = @tracer&.on_tool_start(
+        id: @function.id,
+        name: @function.name,
+        arguments: @function.arguments,
+        model: @function.model
+      )
+      return if intercepted?
       @queue = Queue.new
       @alive = !@cancelled
       @reactor.submit do
@@ -84,21 +90,20 @@ module LLM::Function::Async
         # tool.
         @window.interrupt!(wait: false) if @cancelled
         task.defer_cancel do
-          result = begin
-            ##
-            # The call opens here, and it is what a deferred ask is issued
-            # against. What the window guarantees is that the raise is not
-            # asked for before the call; the dispatch itself is code, and a
-            # raise can land in it, which is the same gap `Fork::Job` has
-            # between `running!` and `runner.call`.
+          begin
             @window.running!
-            function.call
-          rescue LLM::Interrupt => ex
             ##
-            # The interrupt is the block's result, and the queue carries it
-            # to the caller.
-            ex
+            # The 'function.call' method call will rescue
+            # subclasses of StandardError and turn it into
+            # a LLM::Function::Return object. An LLM::Interrupt
+            # escapes this method call, and it is rescued
+            # here and pushed onto the queue.
+            @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            @queue << function.call
+          rescue LLM::Interrupt => ex
+            @queue << ex
           ensure
+            @finished_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             ##
             # The tool has answered, so a cancel that arrives from here on
             # asks nothing - which is the no-op a cancel that arrives once
@@ -112,17 +117,9 @@ module LLM::Function::Async
             # `interrupted?` means.
             function.interrupt! if @window.interrupted?
           end
-          @queue << result
         end
-      rescue LLM::Interrupt, StandardError => e
-        ##
-        # This runs after the `defer_cancel` block's `ensure`, so the tool is
-        # told first and the caller second. It answers a hook whose own
-        # error unwound past the push, and it is the backstop for an
-        # interrupt that arrived from somewhere other than the call above -
-        # which is why the interrupt is pushed and not raised on.
+      rescue LLM::Interrupt => e
         @queue << e
-        raise unless LLM::Interrupt === e
       end
       nil
     end
@@ -165,36 +162,16 @@ module LLM::Function::Async
     alias_method :cancel!, :interrupt!
 
     ##
-    # Wait for the result queue to contain a value.
-    #
-    # It stops the reactor on the way out, which is also where a cancel's
-    # cost is paid: `interrupt!` is a message and a return like every other
-    # strategy's, and a tool that will not stop meets the join and the kill
-    # here rather than in the caller's cancel.
-    #
-    # **A second wait is answered from what the first one took.** `pop` takes
-    # the item, so holding it is what makes a task answerable more than once -
-    # which is what `Thread#value` does for the other in-process strategy, and
-    # what the ractor's task is asserted to do. The exception case is held the
-    # same way, so a call that was interrupted re-raises on every wait rather
-    # than raising once and then blocking on an empty queue.
-    #
-    # Anything that is an exception is raised rather than returned, which is
-    # what `Thread#value` and `Fiber#value` do. An interrupt is the usual
-    # one, and a hook that raised from the block's `ensure` is the other.
-    #
-    # The guarded path returns before any of that, so a task whose guard
-    # blocked it does not stop a reactor it never used - which matters in a
-    # group, where the reactor is not its own.
-    # @return [LLM::Function::Return]
+    # @see LLM::Function::Task#wait
+    # @return (see LLM::Function::Task#wait)
     def wait
-      return @guarded if @guarded
+      return @intercepted if intercepted?
+      return @result.unbox if @result
       begin
         spawn unless @queue
-        @result ||= @queue.pop
+        @result = LLM::Object.from(unbox: @queue.pop)
         @alive = false
-        raise @result if Exception === @result
-        @result
+        @result.unbox
       ensure
         @reactor&.stop
       end

data/lib/llm/function/fiber/group.rb

@@ -36,10 +36,10 @@ module LLM::Function::Fiber
     alias_method :cancel!, :interrupt!
 
     ##
+    # @see LLM::Function::Group#wait
     # @return [Array<LLM::Function::Return>]
     def wait
-      spawn unless @spawned
-      @tasks.map(&:wait)
+      super
     end
     alias_method :value, :wait
   end

data/lib/llm/function/fiber/task.rb

@@ -36,7 +36,13 @@ module LLM::Function::Fiber
     ##
     # @return [nil]
     def spawn
-      return if @guarded
+      @span = @tracer&.on_tool_start(
+        id: @function.id,
+        name: @function.name,
+        arguments: @function.arguments,
+        model: @function.model
+      )
+      return if intercepted?
       if Fiber.scheduler.nil?
         raise ArgumentError, "Fiber concurrency requires Fiber.scheduler"
       elsif !Fiber.scheduler.respond_to?(:fiber_interrupt)
@@ -94,22 +100,12 @@ module LLM::Function::Fiber
             # to prevent - this fiber raised before the call was reached, so
             # the tool's own `rescue` never saw the interrupt.
             @window.running!
+            @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             @queue << function.call
-          rescue LLM::Interrupt, StandardError => ex
-            ##
-            # The interrupt is stored on the queue rather than raised on.
-            # `LLM::Interrupt` is a subclass of `Exception`, and one that is
-            # left to raise kills the scheduler's thread and takes the tasks
-            # running on it with it - the caller reads the queue and raises
-            # the interrupt on its own thread or fiber, and this task exits
-            # silently.
-            #
-            # The rescue names the interrupt rather than leaving it to a bare
-            # rescue, because a bare rescue - and `rescue => ex` - reaches
-            # only `StandardError`.
+          rescue LLM::Interrupt => ex
             @queue << ex
-            raise unless LLM::Interrupt === ex
           ensure
+            @finished_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             ##
             # The tool has answered, so a cancel that arrives from here on
             # asks nothing - which is the no-op a cancel that arrives once
@@ -158,24 +154,14 @@ module LLM::Function::Fiber
     alias_method :cancel!, :interrupt!
 
     ##
-    # Wait for the body to hand its result back.
-    #
-    # **It answers more than once.** `Queue#pop` takes the item, so the value
-    # is kept rather than popped again, and a second wait is answered from
-    # what the first one took - the same way `Thread#value` answers, and the
-    # way `LLM::Function::Ractor::Task` is expected to.
-    #
-    # Anything that is an exception is raised rather than returned. An
-    # interrupt is the usual one: a held cancel arrives here as the exception
-    # the block ended with, and so does one raised at a call that was already
-    # running.
-    # @return [LLM::Function::Return]
+    # @see LLM::Function::Task#wait
+    # @return (see LLM::Function::Task#wait)
     def wait
-      return @guarded if @guarded
+      return @intercepted if intercepted?
+      return @result.unbox if @result
       spawn unless @fiber
-      @result ||= @queue.pop
-      raise @result if Exception === @result
-      @result
+      @result = LLM::Object.from(unbox: @queue.pop)
+      @result.unbox
     end
     alias_method :value, :wait
 

data/lib/llm/function/fork/group.rb

@@ -35,10 +35,10 @@ module LLM::Function::Fork
     alias_method :cancel!, :interrupt!
 
     ##
+    # @see LLM::Function::Group#wait
     # @return [Array<LLM::Function::Return>]
     def wait
-      spawn unless @spawned
-      @tasks.map(&:wait)
+      super
     end
     alias_method :value, :wait
   end

data/lib/llm/function/fork/job.rb

@@ -40,11 +40,11 @@ class LLM::Function
       # result is written, so an interrupt that arrives once the work is
       # done is a no-op rather than a reason to throw the result away.
       @window.finished!
-      @ch.result.write([:result, result])
+      @ch.result.write([:result, result, finished_at])
     rescue LLM::Interrupt
-      @ch.result.write([:interrupt])
+      @ch.result.write([:interrupt, nil, finished_at])
     rescue => ex
-      @ch.result.write([:result, error(ex)])
+      @ch.result.write([:result, error(ex), finished_at])
     ensure
       ##
       # For the paths above that did not reach the line, and nil-safe for
@@ -86,7 +86,7 @@ class LLM::Function
       thread = ::Thread.new do
         ready << true
         ##
-        # Only the receive is guarded: it raises when the parent has gone,
+        # Only the receive is rescued: it raises when the parent has gone,
         # and nothing else in this block should be answerable to that
         # rescue. A hook that raises must not be swallowed by it, and must
         # not take the raise with it either - hence the `ensure` below,
@@ -113,5 +113,9 @@ class LLM::Function
       ready.pop
       thread
     end
+
+    def finished_at
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
   end
 end

data/lib/llm/function/fork/task.rb

@@ -12,7 +12,6 @@ class LLM::Function
     # @return [LLM::Function::Fork::Task]
     def initialize(fn, options = {})
       super
-      @tracer = options.fetch(:tracer, nil)
       @spawned = false
       @waited = false
       @cancelled = false
@@ -21,11 +20,13 @@ class LLM::Function
     ##
     # @return [LLM::Function::Fork::Task]
     def spawn
-      return if @guarded
       @span = @tracer&.on_tool_start(
-        id: @function.id, name: @function.name,
-        arguments: @function.arguments, model: @function.model
+        id: @function.id,
+        name: @function.name,
+        arguments: @function.arguments,
+        model: @function.model
       )
+      return if intercepted?
       @ch = channels
       ##
       # **A cancel that arrived before this is written now, before the fork.**
@@ -38,6 +39,7 @@ class LLM::Function
         @cancelled = false
         @ch.control.write(:interrupt)
       end
+      @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @pid = Kernel.fork do
         ##
         # The child inherits the parent's terminal. When
@@ -95,12 +97,12 @@ class LLM::Function
     # until its watcher looks, which is how a cancel that arrives a moment
     # later is delivered too.
     #
-    # A task the guard blocked never forks, and one that has answered has
+    # A task the intercept blocked never forks, and one that has answered has
     # nothing left to tell: both are a no-op, the way
     # {LLM::Function::Return#interrupt!} says one is.
     # @return [nil]
     def interrupt!
-      return nil if @waited || @guarded
+      return nil if @waited || @intercepted
       if @ch
         @ch.control.write(:interrupt)
       else
@@ -132,34 +134,27 @@ class LLM::Function
     # it would be an exception to the rule that a tool's failure is in band.
     # @return [LLM::Function::Return]
     def wait
-      return @guarded if @guarded
-      raise @result if Exception === @result
-      return @result if @result
+      return @intercepted if intercepted?
+      return @result.unbox if @result
       spawn unless @spawned
-      kind, data = @ch.result.recv
+      kind, data, @finished_at = @ch.result.recv
       @result = case kind
-                when :interrupt then LLM::Interrupt.new
-                when :result then Return.new(data[:id], data[:name], data[:value])
-                else raise ArgumentError, "Unknown fork message: #{kind.inspect}"
+                when :interrupt then LLM::Object.from(unbox: LLM::Interrupt.new)
+                when :result then LLM::Object.from(unbox: Return.new(data[:id], data[:name], data[:value]))
+                else raise ArgumentError, "unknown fork message: #{kind.inspect}"
                 end
-      raise @result if Exception === @result
       reap
-      @tracer&.on_tool_finish(result: @result, span: @span)
-      @result
+      @result.unbox
     rescue EOFError
       ##
-      # Held in `@result` rather than answered once, so a second wait is given
-      # the same return the way it is for every other ending.
+      # Stored in `@result` so a second wait is
+      # given the same return as the first call.
       reap
-      @result = Return.new(@function.id, @function.name, {
-        error: true,
-        type: EOFError.name,
-        message: "the tool exited unexpectedly"
-      })
-      @tracer&.on_tool_finish(result: @result, span: @span)
-      @result
+      val = @function.return(error: true, type: EOFError.name, message: "the tool exited unexpectedly")
+      @result = LLM::Object.from(unbox: val)
+      @result.unbox
     ensure
-      if @guarded.nil?
+      if @intercepted.nil?
         reap
         [@ch.control, @ch.result].each { _1.close unless _1.closed? } if @ch
       end
@@ -178,9 +173,9 @@ class LLM::Function
     # The controls and results channels.
     #
     # They are built by `spawn` and not by {#interrupt!}, so a task that never
-    # forks never opens a socketpair - a guard blocks many of them, and that is
-    # the common case. A cancel that arrives before `spawn` is recorded instead,
-    # and written by it.
+    # forks never opens a socketpair - an intercept blocks many of them, and
+    # that is the common case. A cancel that arrives before `spawn` is recorded
+    # instead, and written by it.
     # @return [LLM::Object]
     def channels
       LLM::Object.from(
@@ -197,7 +192,7 @@ class LLM::Function
     # only be reaped once.
     # @return [void]
     def reap
-      return if @waited || @guarded || !@pid
+      return if @waited || @intercepted || !@pid
       ::Process.waitpid(@pid)
       @waited = true
     rescue Errno::ECHILD

data/lib/llm/function/group.rb

@@ -2,10 +2,11 @@
 
 class LLM::Function
   ##
-  # Abstract base class for all concurrency strategy groups.
+  # Abstract superclass for all concurrency strategy groups.
   # Each strategy (sequential, thread, fiber, async, fork, ractor)
-  # subclasses this and implements {#alive?}, {#interrupt!}, and
-  # {#wait}.
+  # subclasses this and implements {#spawn}, {#alive?} and
+  # {#interrupt!}. {#wait} is shared, and a strategy whose tasks
+  # report themselves answers with one of its own.
   class Group
     ##
     # @abstract
@@ -30,10 +31,37 @@ class LLM::Function
     alias_method :cancel!, :interrupt!
 
     ##
-    # @abstract
+    # This method waits for one or more tasks to
+    # return. Within this method, the tracer
+    # associated with a task closes the `on_tool_start`
+    # span that was opened when the task spawned.
+    #
+    # @note
+    #  This method might raise an {LLM::Interrupt}
+    #  if one or more tasks were interrupted but
+    #  only after the tracer has accounted for each
+    #  task and collected an exit status from each
+    #  of them.
+    # @raise [LLM::Interrupt]
     # @return [Array<LLM::Function::Return>]
     def wait
-      raise NotImplementedError
+      spawn unless @spawned
+      interrupt = nil
+      vals = @tasks.map do |task|
+        val, started_at, finished_at = task.wait, task.started_at, task.finished_at
+        if LLM::Interrupt === val
+          interrupt = val
+          task.tracer&.on_tool_interrupt(ex: val, span: task.span, started_at:, finished_at:)
+        else
+          if val.error?
+            task.tracer&.on_tool_error(ex: val, span: task.span, started_at:, finished_at:)
+          else
+            task.tracer&.on_tool_finish(result: val, span: task.span, started_at:, finished_at:)
+          end
+          val
+        end
+      end
+      interrupt ? raise(interrupt) : vals
     end
     alias_method :value, :wait
   end