class Riffer::Tools::Runtime

Riffer::Tools::Runtime handles tool call execution for an agent.

Composes with a Riffer::Runner for concurrency control and provides execute as the sole public entry point.

Subclass and override dispatch_tool_call to customize how individual tool calls are dispatched (e.g., HTTP, gRPC).

runtime = Riffer::Tools::Runtime::Inline.new
results = runtime.execute(tool_calls, tools: tools, context: context)

Public Class Methods

new (runner:)

Source

# File lib/riffer/tools/runtime.rb, line 25
def initialize(runner:)
  raise NotImplementedError, "#{self.class} is abstract — use a subclass like Riffer::Tools::Runtime::Inline" if instance_of?(Riffer::Tools::Runtime)
  @runner = runner
end

runner: the concurrency runner to use for batch execution.

Subclasses must provide a runner; instantiating Riffer::Tools::Runtime directly raises NotImplementedError.

Public Instance Methods

around_tool_call (tool_call, context:, assistant_message: nil) { || ... }

Source

# File lib/riffer/tools/runtime.rb, line 69
def around_tool_call(tool_call, context:, assistant_message: nil)
  yield
end

Hook that wraps each tool call execution. Override in subclasses to customize. Must yield to continue execution.

The default implementation simply yields.

class InstrumentedRuntime < Riffer::Tools::Runtime::Inline
  private

  def around_tool_call(tool_call, context:, assistant_message: nil)
    start = Time.now
    result = yield
    Rails.logger.info("Tool #{tool_call.name} took #{Time.now - start}s")
    result
  end
end

execute (tool_calls, tools:, context:, assistant_message: nil)

Source

# File lib/riffer/tools/runtime.rb, line 42
def execute(tool_calls, tools:, context:, assistant_message: nil)
  @runner.map(tool_calls, context: context) do |tool_call|
    result = around_tool_call(tool_call, context: context, assistant_message: assistant_message) do
      dispatch_tool_call(tool_call, tools: tools, context: context, assistant_message: assistant_message)
    end
    [tool_call, result]
  end
end

Executes a batch of tool calls, returning [tool_call, response] pairs.

tool_calls: the tool calls to execute.
tools: the resolved tool classes.
context: the context hash.
assistant_message: the assistant message that produced these tool

calls, when known. Forwarded to +around_tool_call+ and
+dispatch_tool_call+ so subclasses can access it (e.g. for
instrumentation that needs the accompanying assistant text).