riffer-rig 0.6.0 → 0.8.0

data/lib/riffer/rig/loader.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Loader
+  class ConfigurationError < StandardError; end
+
+  PROVIDER_LIST = Riffer::Rig::Settings::PROVIDERS.join(', ') #: String
+
+  ONBOARDING_QUESTION = 'Which model should riffer use? Enter provider/name, ' \
+                        "with a provider from: #{PROVIDER_LIST}".freeze #: String
+
+  NO_MODEL = 'No model is set: pass --model provider/name, set RIFFER_MODEL, or set "model" in ' \
+             "~/.riffer/settings.json, with a provider from: #{PROVIDER_LIST}".freeze #: String
+
+  EXTENSION_FEATURE = 'riffer/rig/extension' #: String
+
+  private_constant :EXTENSION_FEATURE, :PROVIDER_LIST, :ONBOARDING_QUESTION, :NO_MODEL
+
+  # @rbs @cwd: String
+  # @rbs @host: Riffer::Rig::Hosts::_Host
+  # @rbs @env: Riffer::Rig::Env
+  # @rbs @home: String
+  # @rbs @riffer_config: Riffer::Config
+  # @rbs @tracked_files: Array[String]
+
+  # @dynamic tracked_files
+  attr_reader :tracked_files #: Array[String]
+
+  # @rbs cwd: String
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
+  # @rbs home: String
+  # @rbs riffer_config: Riffer::Config
+  # @rbs model: String?
+  # @rbs extensions: bool
+  # @rbs skills: bool
+  # @rbs agents_md: bool
+  # @rbs tools: Array[String]?
+  # @rbs max_steps: Integer?
+  # @rbs return: Riffer::Rig::Runtime
+  def self.runtime(
+    cwd:,
+    host:,
+    env: Riffer::Rig::Env.load,
+    home: Dir.home,
+    riffer_config: Riffer.config,
+    model: nil,
+    extensions: true,
+    skills: true,
+    agents_md: true,
+    tools: nil,
+    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
+  )
+    new(cwd:, host:, env:, home:, riffer_config:).runtime(model:, extensions:, skills:, agents_md:, tools:, max_steps:)
+  end
+
+  # @rbs cwd: String
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs env: Riffer::Rig::Env | Riffer::Rig::Env::Invalid
+  # @rbs home: String
+  # @rbs riffer_config: Riffer::Config
+  # @rbs return: void
+  def initialize(cwd:, host:, env: Riffer::Rig::Env.load, home: Dir.home, riffer_config: Riffer.config)
+    raise ConfigurationError, env.message if env.is_a?(Riffer::Rig::Env::Invalid)
+
+    @cwd = cwd
+    @host = host
+    @env = env
+    @home = home
+    @riffer_config = riffer_config
+    @tracked_files = []
+  end
+
+  # @rbs model: String?
+  # @rbs extensions: bool
+  # @rbs skills: bool
+  # @rbs agents_md: bool
+  # @rbs tools: Array[String]?
+  # @rbs max_steps: Integer?
+  # @rbs return: Riffer::Rig::Runtime
+  def runtime(
+    model: nil,
+    extensions: true,
+    skills: true,
+    agents_md: true,
+    tools: nil,
+    max_steps: Riffer::Rig::Runtime::DEFAULT_MAX_STEPS
+  )
+    settings = Riffer::Rig::Settings.merge(
+      Riffer::Rig::Settings.read(home_settings_path),
+      Riffer::Rig::Settings.read(File.join(@cwd, '.riffer', 'settings.json'))
+    )
+    document = Riffer::Rig::Settings::Document.new(settings)
+    selected = select_model(model || @env.model || document.model)
+    provider = Riffer::Rig::Settings.provider_for(selected).to_s
+    credentials = { provider.to_sym => credentials_for(provider) }
+    stripped = { skills: skills, agents_md: agents_md }.reject { |_name, kept| kept }.keys
+    loaded = Riffer::Rig::Bundled::BY_NAME.except(*document.disabled.map(&:to_sym), *stripped).values
+    loaded += load_rig_files(document.autoload) if extensions
+
+    Riffer::Rig::Runtime.new(
+      selected,
+      extensions: loaded,
+      tools: tools,
+      settings: settings,
+      host: @host,
+      cwd: @cwd,
+      max_steps: max_steps,
+      credentials: credentials,
+      pricing: document.models,
+      riffer_config: @riffer_config,
+      model_options: Riffer::Rig::Settings.model_options(selected, document.reasoning)
+    )
+  end
+
+  private
+
+  # @rbs autoload: bool
+  # @rbs return: Array[Riffer::Rig::Extension]
+  def load_rig_files(autoload)
+    recorded = gem_extension_files(autoload).flat_map { |file| load_file(File.expand_path(file), track: false) }
+    home = File.expand_path(File.join(@home, '.riffer', 'rig.rb'))
+    recorded.concat(load_file(home, track: true)) if File.file?(home)
+    project = File.expand_path(File.join(@cwd, '.riffer', 'rig.rb'))
+    recorded.concat(load_file(project, track: true)) if File.file?(project) && trusted?(project)
+    recorded
+  end
+
+  # @rbs autoload: bool
+  # @rbs return: Array[String]
+  def gem_extension_files(autoload)
+    return [] unless autoload
+
+    Gem.find_files(EXTENSION_FEATURE)
+  end
+
+  # @rbs path: String
+  # @rbs return: bool
+  def trusted?(path)
+    stored = Riffer::Rig::Trust.read(trust_path)[path]
+    return stored unless stored.nil?
+
+    asked = @host.capabilities.include?(:confirm)
+    decision = asked ? @host.confirm("Trust #{path}?") : false
+    Riffer::Rig::Trust.store(trust_path, path, decision) if asked
+    decision
+  end
+
+  # @rbs return: String
+  def trust_path
+    File.join(@home, '.riffer', 'trust.json')
+  end
+
+  # @rbs path: String
+  # @rbs track: bool
+  # @rbs return: Array[Riffer::Rig::Extension]
+  def load_file(path, track:)
+    before = Riffer::Rig.extensions
+    before_features = $LOADED_FEATURES.dup
+    begin
+      load path
+    rescue StandardError => e
+      track_loaded(before_features, path) if track
+      @host.notify("#{path} failed to load: #{e.message}", level: :error)
+      return []
+    end
+    track_loaded(before_features, path) if track
+    Riffer::Rig.extensions.values.reject { |extension| before[extension.name] == extension }
+  end
+
+  # @rbs before_features: Array[String]
+  # @rbs path: String
+  # @rbs return: void
+  def track_loaded(before_features, path)
+    recorded = ($LOADED_FEATURES - before_features) + [path] #: Array[String]
+    @tracked_files.concat(recorded.select { |feature| local?(feature) })
+  end
+
+  # @rbs feature: String
+  # @rbs return: bool
+  def local?(feature)
+    roots = [File.expand_path(File.join(@home, '.riffer')), File.expand_path(@cwd)] #: Array[String]
+    roots.any? { |root| feature.start_with?("#{root}#{File::SEPARATOR}") }
+  end
+
+  # @rbs configured: String?
+  # @rbs return: String
+  def select_model(configured)
+    model = configured || ask_for_model
+    rejection = Riffer::Rig::Settings.rejection(model)
+    raise ConfigurationError, rejection if rejection
+
+    Riffer::Rig::Settings.store_model(model, path: home_settings_path) unless configured
+    model
+  end
+
+  # @rbs return: String
+  def ask_for_model
+    answer = asking_host.ask(ONBOARDING_QUESTION).to_s.strip
+    raise ConfigurationError, NO_MODEL if answer.empty?
+
+    answer
+  end
+
+  # @rbs provider: String
+  # @rbs return: Hash[Symbol, String]
+  def credentials_for(provider)
+    resolution = Riffer::Rig::Credentials.resolve(
+      provider,
+      host: asking_host,
+      env: @env,
+      auth_path: File.join(@home, '.riffer', 'auth.json'),
+      settings_path: home_settings_path
+    )
+    raise ConfigurationError, missing_credentials(provider, resolution.missing) unless resolution.missing.empty?
+
+    Riffer::Rig::Credentials.apply(provider, resolution.values, config: @riffer_config)
+    resolution.values
+  end
+
+  # @rbs provider: String
+  # @rbs missing: Array[Symbol]
+  # @rbs return: String
+  def missing_credentials(provider, missing)
+    setup = Riffer::Rig::ProviderSetup.for(provider)
+    fields = setup.fields.select { |field| missing.include?(field.name) }
+    wanted = fields.map { |field| "#{field.name} (#{field.env.join(' or ')})" }.join(', ')
+    "#{provider} has no #{wanted}; set it in the environment or run riffer interactively to paste it" \
+      "#{" (create one at #{setup.url})" if setup.url}"
+  end
+
+  # @rbs return: Riffer::Rig::Hosts::_Host
+  def asking_host
+    @host.capabilities.include?(:ask) ? @host : Riffer::Rig::Hosts::Null.new
+  end
+
+  # @rbs return: String
+  def home_settings_path
+    File.join(@home, '.riffer', 'settings.json')
+  end
+end

data/lib/riffer/rig/mcp/declaration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Mcp::Declaration
+  include Riffer::Rig::Support::Equatable
+
+  # @dynamic url, headers
+  attr_reader :url #: String
+  attr_reader :headers #: Hash[String, String]
+
+  # @rbs url: String
+  # @rbs headers: Hash[String, String]
+  # @rbs return: void
+  def initialize(url:, headers:)
+    @url = url
+    @headers = headers
+    freeze
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { url: url, headers: headers }
+  end
+end

data/lib/riffer/rig/mcp/server.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Mcp::Server
+  # @dynamic declaration, registration
+  attr_reader :declaration #: Riffer::Rig::Mcp::Declaration
+  attr_reader :registration #: Riffer::Mcp::Registration
+
+  # @rbs declaration: Riffer::Rig::Mcp::Declaration
+  # @rbs registration: Riffer::Mcp::Registration
+  # @rbs return: void
+  def initialize(declaration:, registration:)
+    @declaration = declaration
+    @registration = registration
+    freeze
+  end
+end

data/lib/riffer/rig/mcp.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Mcp
+  extend self
+
+  # @rbs home: Hash[Symbol, untyped]
+  # @rbs project: Hash[Symbol, untyped]
+  # @rbs return: Hash[Symbol, untyped]
+  def merge(home, project)
+    home.merge(project, servers: home[:servers].to_h.merge(project[:servers].to_h))
+  end
+end

data/lib/riffer/rig/prompts/agents_md.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Prompts::AgentsMd
+  extend self
+
+  FRAMING = 'The user wrote the following instructions in AGENTS.md files, ordered from the most general to ' \
+            'the one closest to the working directory. Follow them; where they conflict with the guidance ' \
+            'above, they take precedence, and where they conflict with each other, the later file wins.' #: String
+
+  # @rbs cwd: String
+  # @rbs return: Array[String]
+  def paths(cwd)
+    global  = File.join(Dir.home, '.riffer', 'AGENTS.md')
+    project = Riffer::Rig::Directories.ancestors(File.expand_path(cwd)).reverse.map { |dir| File.join(dir, 'AGENTS.md') }
+    [global, *project].uniq.select { |path| File.file?(path) }
+  end
+
+  # @rbs cwd: String
+  # @rbs return: String?
+  def section(cwd)
+    blocks = paths(cwd).map { |path| block(path) }
+    [FRAMING, *blocks].join("\n\n") unless blocks.empty?
+  end
+
+  private
+
+  # @rbs path: String
+  # @rbs return: String
+  def block(path)
+    "<project_instructions path=\"#{path}\">\n#{File.read(path)}\n</project_instructions>"
+  end
+end

data/lib/riffer/rig/prompts.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Prompts
+end

data/lib/riffer/rig/registrar.rb

@@ -1,19 +1,55 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Registrar
-  # @rbs @tools: Array[singleton(Riffer::Tool)]
+  class NameCollisionError < StandardError; end
+
+  CORE_SETTINGS_KEYS = %w[model reasoning models reload extensions sessions providers tools].freeze #: Array[String]
+
+  EVENTS = %i[
+    session_start session_end
+    before_prompt before_tool_call before_request
+    after_tool_call after_response turn_end
+    stream
+  ].freeze #: Array[Symbol]
+
+  # @rbs @tools: Hash[String, singleton(Riffer::Tool)]
   # @rbs @prompts: Hash[Symbol, ^(Riffer::Rig::Runtime) -> String?]
+  # @rbs @commands: Hash[String, Riffer::Rig::Command]
+  # @rbs @skill_sources: Array[^(Riffer::Rig::Runtime) -> Riffer::Skills::Backend]
+  # @rbs @declared_settings: Hash[Symbol, untyped]
+  # @rbs @given_settings: Hash[Symbol, untyped]
+  # @rbs @mcp_servers: Hash[String, Riffer::Rig::Mcp::Declaration]
+  # @rbs @hooks: Hash[Symbol, Array[^(Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base) -> untyped]]
 
+  # @dynamic extension
+  attr_reader :extension #: String
+
+  # @rbs extension: String
+  # @rbs settings: Hash[Symbol, untyped]
   # @rbs return: void
-  def initialize
-    @tools = []
+  def initialize(extension, settings = {})
+    @extension = extension
+    @tools = {}
     @prompts = {}
+    @commands = {}
+    @skill_sources = []
+    @declared_settings = {}
+    @given_settings = settings
+    @mcp_servers = {}
+    @hooks = EVENTS.to_h { |event| [event, []] }
+  end
+
+  # @rbs return: NameCollisionError?
+  def collision
+    return unless CORE_SETTINGS_KEYS.include?(@extension)
+
+    NameCollisionError.new("extension name #{@extension} collides with a core settings key")
   end
 
   # @rbs klass: singleton(Riffer::Tool)
   # @rbs return: void
   def tool(klass)
-    @tools << klass
+    @tools[klass.identifier] = klass
   end
 
   # @rbs name: Symbol
@@ -23,7 +59,46 @@ class Riffer::Rig::Registrar
     @prompts[name] = block
   end
 
-  # @rbs return: Array[singleton(Riffer::Tool)]
+  # @rbs name: String
+  # @rbs description: String
+  # @rbs &block: (Riffer::Rig::Command::Context) -> void
+  # @rbs return: void
+  def command(name, description:, &)
+    @commands[name] = Riffer::Rig::Command.new(name, description: description, extension: @extension, &)
+  end
+
+  # @rbs &block: (Riffer::Rig::Runtime) -> Riffer::Skills::Backend
+  # @rbs return: void
+  def skills(&block)
+    @skill_sources << block
+  end
+
+  # @rbs key: Symbol
+  # @rbs default: untyped
+  # @rbs return: void
+  def setting(key, default:)
+    @declared_settings[key] = default
+  end
+
+  # @rbs name: String
+  # @rbs url: String
+  # @rbs headers: Hash[String, String]
+  # @rbs return: void
+  def mcp(name, url:, headers: {})
+    @mcp_servers[name] = Riffer::Rig::Mcp::Declaration.new(url: url, headers: headers)
+  end
+
+  # @rbs event: Symbol
+  # @rbs &block: (Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base) -> untyped
+  # @rbs return: void
+  def on(event, &block)
+    hooks = @hooks.fetch(event) do
+      raise Riffer::ArgumentError, "unknown event #{event.inspect}; expected one of #{EVENTS.join(', ')}"
+    end
+    hooks << block
+  end
+
+  # @rbs return: Hash[String, singleton(Riffer::Tool)]
   def tools
     @tools.dup
   end
@@ -32,4 +107,44 @@ class Riffer::Rig::Registrar
   def prompts
     @prompts.dup
   end
+
+  # @rbs return: Hash[String, Riffer::Rig::Command]
+  def commands
+    @commands.dup
+  end
+
+  # @rbs return: Array[^(Riffer::Rig::Runtime) -> Riffer::Skills::Backend]
+  def skill_sources
+    @skill_sources.dup
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def settings
+    @declared_settings.merge(@given_settings)
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def declared_settings
+    @declared_settings.dup
+  end
+
+  # @rbs return: Hash[String, Riffer::Rig::Mcp::Declaration]
+  def mcp_servers
+    @mcp_servers.dup
+  end
+
+  # @rbs return: Array[String]
+  def registrations
+    [
+      *@tools.keys.map { |identifier| "tool #{identifier}" },
+      *@prompts.keys.map { |name| "prompt section #{name}" },
+      *@commands.keys.map { |name| "command #{name}" },
+      *@mcp_servers.keys.map { |name| "MCP server #{name}" }
+    ]
+  end
+
+  # @rbs return: Hash[Symbol, Array[^(Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base) -> untyped]]
+  def hooks
+    @hooks.transform_values(&:dup)
+  end
 end

data/lib/riffer/rig/runtime/blocked.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Runtime::Blocked
+  # @dynamic reason
+  attr_reader :reason #: String
+
+  # @rbs reason: String
+  # @rbs return: void
+  def initialize(reason)
+    @reason = reason
+    freeze
+  end
+end

data/lib/riffer/rig/runtime/hooks.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Runtime::Hooks
+  # @rbs @hooks: Hash[Symbol, Array[^(Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base) -> untyped]]
+  # @rbs @host: Riffer::Rig::Hosts::_Host
+
+  # @rbs hooks: Hash[Symbol, Array[^(Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base) -> untyped]]
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs return: void
+  def initialize(hooks, host)
+    @hooks = hooks
+    @host = host
+  end
+
+  # @rbs name: Symbol
+  # @rbs event: Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base
+  # @rbs return: void
+  def observe(name, event)
+    @hooks.fetch(name).each { |hook| call(name, hook, event) }
+  end
+
+  # @rbs text: String
+  # @rbs return: String | Riffer::Rig::Runtime::Blocked
+  def before_prompt(text)
+    accepts = ->(value) { value.is_a?(String) }
+    announce(veto(:before_prompt, text, accepts) { |current| Riffer::Rig::Events::BeforePrompt.new(current) })
+  end
+
+  # @rbs tool: String
+  # @rbs args: Hash[Symbol, untyped]
+  # @rbs return: Hash[Symbol, untyped] | Riffer::Rig::Runtime::Blocked
+  def before_tool_call(tool, args)
+    accepts = ->(value) { value.is_a?(Hash) }
+    veto(:before_tool_call, args, accepts) { |current| Riffer::Rig::Events::BeforeToolCall.new(tool, current) }
+  end
+
+  # @rbs messages: Array[::Riffer::Messages::Base]
+  # @rbs return: Array[::Riffer::Messages::Base] | Riffer::Rig::Runtime::Blocked
+  def before_request(messages)
+    accepts = ->(value) { value.is_a?(Array) && value.all?(::Riffer::Messages::Base) }
+    announce(veto(:before_request, messages, accepts) { |current| Riffer::Rig::Events::BeforeRequest.new(current) })
+  end
+
+  private
+
+  # @rbs name: Symbol
+  # @rbs payload: untyped
+  # @rbs accepts: ^(untyped) -> bool
+  # @rbs &: (untyped) -> Riffer::Rig::Events::_Event
+  # @rbs return: untyped
+  def veto(name, payload, accepts)
+    @hooks.fetch(name).reduce(payload) do |current, hook|
+      result = call(name, hook, yield(current))
+      verdict, reason = result
+      break Riffer::Rig::Runtime::Blocked.new(reason&.to_s || "blocked by a #{name} hook") if verdict == :block
+
+      accepts.call(result) ? result : current
+    end
+  end
+
+  # @rbs outcome: untyped
+  # @rbs return: untyped
+  def announce(outcome)
+    @host.notify(outcome.reason, level: :warning) if outcome.is_a?(Riffer::Rig::Runtime::Blocked)
+    outcome
+  end
+
+  # @rbs name: Symbol
+  # @rbs hook: ^(Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base) -> untyped
+  # @rbs event: Riffer::Rig::Events::_Event | ::Riffer::StreamEvents::Base
+  # @rbs return: untyped
+  def call(name, hook, event)
+    hook.call(event)
+  rescue StandardError => e
+    @host.notify("#{name} hook failed: #{e.message}", level: :error)
+    nil
+  end
+end

data/lib/riffer/rig/runtime/request_guardrail.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# riffer runs its before guardrails once per run, just ahead of the first
+# request; the Runtime's on_message observer covers the requests after it.
+class Riffer::Rig::Runtime::RequestGuardrail < Riffer::Guardrail
+  # @rbs @hooks: Riffer::Rig::Runtime::Hooks
+
+  # @rbs hooks: Riffer::Rig::Runtime::Hooks
+  # @rbs return: void
+  def initialize(hooks:)
+    super()
+    @hooks = hooks
+  end
+
+  # @rbs messages: Array[Riffer::Messages::Base]
+  # @rbs context: untyped
+  # @rbs return: Riffer::Guardrails::Result
+  def process_input(messages, context:)
+    verdict = @hooks.before_request(messages)
+    return block(verdict.reason) if verdict.is_a?(Riffer::Rig::Runtime::Blocked)
+
+    verdict.equal?(messages) ? pass(messages) : transform(verdict.dup)
+  end
+end

data/lib/riffer/rig/runtime/tool_runtime.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class Riffer::Rig::Runtime::ToolRuntime < Riffer::Tools::Runtime
+  # @rbs @hooks: Riffer::Rig::Runtime::Hooks
+
+  # @rbs hooks: Riffer::Rig::Runtime::Hooks
+  # @rbs return: void
+  def initialize(hooks)
+    # Sequential, so hooks never run concurrently.
+    super(runner: Riffer::Runner::Sequential.new)
+    @hooks = hooks
+  end
+
+  private
+
+  # @rbs tool_call: Riffer::Messages::Assistant::ToolCall
+  # @rbs tools: Array[singleton(Riffer::Tool)]
+  # @rbs context: Riffer::Agent::Context?
+  # @rbs assistant_message: Riffer::Messages::Assistant?
+  # @rbs return: Riffer::Tools::Response
+  def dispatch_tool_call(tool_call, tools:, context:, assistant_message: nil)
+    args = parse_arguments(tool_call.arguments)
+    return super unless args.is_a?(Hash)
+
+    verdict = @hooks.before_tool_call(tool_call.name, args)
+    return Riffer::Tools::Response.error(verdict.reason, type: :blocked) if verdict.is_a?(Riffer::Rig::Runtime::Blocked)
+
+    call = verdict.equal?(args) ? tool_call : replace_arguments(tool_call, verdict)
+    response = super(call, tools: tools, context: context, assistant_message: assistant_message)
+    @hooks.observe(:after_tool_call, Riffer::Rig::Events::AfterToolCall.new(tool_call.name, verdict, response))
+    response
+  rescue JSON::ParserError
+    super
+  end
+
+  # @rbs tool_call: Riffer::Messages::Assistant::ToolCall
+  # @rbs args: Hash[Symbol, untyped]
+  # @rbs return: Riffer::Messages::Assistant::ToolCall
+  def replace_arguments(tool_call, args)
+    Riffer::Messages::Assistant::ToolCall.new(call_id: tool_call.call_id, name: tool_call.name, arguments: args.to_json)
+  end
+end