riffer-rig 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e833f2a4dfe0b87598e2be9d585f3cb772562ab39a2dd528684a38dca87f63ab
-  data.tar.gz: f469b328103a49e52773c0073e02d8c2fbd06d8cf6779daa50c09b49ab2eba8e
+  metadata.gz: 4a1580a7e4f2ed5e6d1f18714ef469b7d4623bec94552510a836a5f5e5664504
+  data.tar.gz: 7e871b6b1f8c9de6e3788979103f7afe65beea7a9c5fa7813e17b29e4e8eb528
 SHA512:
-  metadata.gz: 696e8b92a7c1b7a3b71e1f628894e89aed725fbe072dba712d94df277fc5730b06d74def094445b02842d0849409b7900038aedf5d65f29f5416d1450a5b5121
-  data.tar.gz: 3dc42ac6e625d292462e00119bd7b3c7a8d1f23ad3c4f66763fff96cbfc3328f962dca67bdc4613e884ba81a6e3f61d9af86f1ba1d8bbd16e0f3caa307ca453c
+  metadata.gz: db021260a12a48c02bb6ff92278819416bcc267bd78015f01f80bd3a9ed64c585e37d17573a3ba47ba28d99bd0ef586665a465782d36a6a85231c08ad4a4fd51
+  data.tar.gz: 5ea0ed0a06d1a318267bd3d63b693f974ff8ca814e26be0eb5837cdac09527bea33a75357f7a1a11b419854ed72810a5d571c8508010e8bd62f327eb922f04eb

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.5.0](https://github.com/bottrall/riffer-rig/compare/v0.4.0...v0.5.0) (2026-09-19)
+
+
+### Features
+
+* add ask, max_steps and riffer response ([#178](https://github.com/bottrall/riffer-rig/issues/178)) ([948d753](https://github.com/bottrall/riffer-rig/commit/948d75354a7d0a5a9d35055b7d890dea9e51f1a1))
+* add Runtime with a per-instance agent, base prompt and tool seam ([#160](https://github.com/bottrall/riffer-rig/issues/160)) ([97019ca](https://github.com/bottrall/riffer-rig/commit/97019ca6f80c95bcf22e443652f1d90d453d02de))
+* type IO streams and JSON boundaries, dropping explicit untyped ([#174](https://github.com/bottrall/riffer-rig/issues/174)) ([22407be](https://github.com/bottrall/riffer-rig/commit/22407befc471d1fbbe14188456ee1ce248ddc4c7))
+
+
+### Bug Fixes
+
+* drain smoother backlog before every animator restart ([#177](https://github.com/bottrall/riffer-rig/issues/177)) ([3126155](https://github.com/bottrall/riffer-rig/commit/3126155fdeba3de2ab2b9905b7e7de55593de834))
+* drop invalid ? optional markers from rbs-inline annotations ([#171](https://github.com/bottrall/riffer-rig/issues/171)) ([60030bf](https://github.com/bottrall/riffer-rig/commit/60030bf7ca930e9d35cbd8c2e3a8ae8ae1692830))
+
 ## [0.4.0](https://github.com/bottrall/riffer-rig/compare/v0.3.0...v0.4.0) (2026-09-13)
 
 

data/lib/riffer/rig/cli.rb

@@ -12,8 +12,8 @@ module Riffer::Rig::CLI
     'openrouter' => 'https://openrouter.ai/keys'
   }.freeze #: Hash[String, String]
 
-  # @rbs output: untyped
-  # @rbs input: untyped
+  # @rbs output: IO
+  # @rbs input: IO
   # @rbs return: Integer
   def start(output: $stdout, input: $stdin)
     theme = Riffer::Rig::UI::Theme.for(output)
@@ -21,8 +21,7 @@ module Riffer::Rig::CLI
     model    = Riffer::Rig::Settings.model
     provider = Riffer::Rig::Settings.provider_for(model)
 
-    api_key = (provider && Riffer::Rig::Credentials.api_key_for(provider)) ||
-              onboard(provider, theme, output:, input:)
+    api_key = (provider && Riffer::Rig::Credentials.api_key_for(provider)) || onboard(provider, theme, output:, input:)
     return 1 if api_key.nil?
 
     configure_provider(provider, api_key)
@@ -55,8 +54,8 @@ module Riffer::Rig::CLI
 
   # @rbs provider: String?
   # @rbs theme: Riffer::Rig::UI::Theme
-  # @rbs output: untyped
-  # @rbs input: untyped
+  # @rbs output: IO
+  # @rbs input: IO
   # @rbs return: String?
   def onboard(provider, theme, output:, input:)
     url  = (provider && PROVIDER_URLS[provider]) || 'your provider'
@@ -85,7 +84,7 @@ module Riffer::Rig::CLI
     (provider && Riffer::Rig::Credentials::PROVIDER_ENV_VARS[provider]) || 'the appropriate API key env var'
   end
 
-  # @rbs input: untyped
+  # @rbs input: IO
   # @rbs return: String?
   def read_secret(input)
     return input.noecho(&:gets) if input.respond_to?(:noecho) && input.tty?

data/lib/riffer/rig/coding_agent.rb

@@ -12,12 +12,7 @@ class Riffer::Rig::CodingAgent < Riffer::Agent
   model Riffer::Rig::Settings.model
   model_options Riffer::Rig::Settings.model_options
 
-  uses_tools [
-    Riffer::Rig::Tools::Read,
-    Riffer::Rig::Tools::Write,
-    Riffer::Rig::Tools::Edit,
-    Riffer::Rig::Tools::Bash
-  ]
+  uses_tools [Riffer::Rig::Tools::Read, Riffer::Rig::Tools::Write, Riffer::Rig::Tools::Edit, Riffer::Rig::Tools::Bash]
 
   skills do
     backend(->(_ctx) { Riffer::Skills::FilesystemBackend.new(GLOBAL_SKILLS_DIR, PROJECT_SKILLS_DIR.call) })

data/lib/riffer/rig/credentials.rb

@@ -54,7 +54,7 @@ module Riffer::Rig::Credentials
   # @rbs return: String
   def save_api_key(provider, key, path: PATH)
     FileUtils.mkdir_p(File.dirname(path), mode: 0o700)
-    data = read(path).tap { |h| h[provider] = key }
+    data = read(path).merge(provider => key)
     File.open(path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |file|
       file.write(JSON.pretty_generate(data))
     end
@@ -68,21 +68,21 @@ module Riffer::Rig::Credentials
   # @rbs return: String?
   def key_from_file(provider, path)
     key = read(path)[provider]
-    return nil unless key.is_a?(String)
-    return key unless key.strip.empty?
+    return nil if key.nil? || key.strip.empty?
 
-    nil
+    key
   end
 
   # The parsed auth file, or an empty hash when the file is absent or
-  # malformed.
+  # malformed. Non-string values can't be keys, so they're dropped here rather
+  # than re-checked by every reader.
   #
   # @rbs path: String
-  # @rbs return: Hash[String, untyped]
+  # @rbs return: Hash[String, String]
   def read(path)
     return {} unless File.file?(path)
 
-    JSON.parse(File.read(path))
+    JSON.parse(File.read(path)).select { |_provider, key| key.is_a?(String) }
   rescue JSON::ParserError
     {}
   end

data/lib/riffer/rig/extension.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# An extension recorded by <tt>Riffer::Rig.extension</tt>: a name, an optional
+# Gem::Requirement on riffer-rig, and the block that runs against a Runtime's
+# registrar. The process registry holds these objects; Runtime.new runs their
+# blocks.
+class Riffer::Rig::Extension
+  # @rbs @name: String
+  # @rbs @requires: Gem::Requirement?
+  # @rbs @block: ^(::Riffer::Rig::Registrar) -> void
+
+  # @dynamic name, requires
+  attr_reader :name #: String
+  attr_reader :requires #: Gem::Requirement?
+
+  # @rbs name: String
+  # @rbs requires: String?
+  # @rbs &block: (::Riffer::Rig::Registrar) -> void
+  # @rbs return: void
+  def initialize(name, requires: nil, &block)
+    @name = name
+    @requires = requires && Gem::Requirement.new(requires)
+    @block = block
+  end
+
+  # @rbs registrar: Riffer::Rig::Registrar
+  # @rbs return: void
+  def run(registrar)
+    @block.call(registrar)
+  end
+end

data/lib/riffer/rig/host.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# A host receives questions and out-of-band messages from a Runtime. It is
+# duck-typed: any object with #ask, #confirm, #notify, #progress and
+# #capabilities is a host.
+#
+#   class HeadlessHost
+#     def capabilities = Set[:notify, :progress].freeze
+#     def ask(*) = nil
+#     def confirm(*) = false
+#     def notify(message, level:) = warn("[#{level}] #{message}")
+#     def progress(label) = yield
+#   end
+#
+# Callers check #capabilities before asking, so a host that declines a
+# capability is never asked and the caller takes the declined path.
+# The do-nothing host: the default +host:+ for a Runtime. Every capability is
+# declined, so callers take the declined path without any UI attempt.
+class Riffer::Rig::Host
+  # @rbs return: Set[Symbol]
+  def capabilities
+    Set.new.freeze
+  end
+
+  # @rbs _question: String?
+  # @rbs options: Array[String]?
+  # @rbs secret: bool
+  # @rbs return: String?
+  def ask(_question = nil, options: nil, secret: false)
+    nil
+  end
+
+  # @rbs _question: String?
+  # @rbs return: bool
+  def confirm(_question = nil)
+    false
+  end
+
+  # @rbs _message: String?
+  # @rbs level: Symbol
+  # @rbs return: void
+  def notify(_message = nil, level: :info)
+    nil
+  end
+
+  # @rbs _label: String?
+  # @rbs &block: ^() -> void
+  # @rbs return: void
+  def progress(_label = nil, &block)
+    block&.call
+  end
+end

data/lib/riffer/rig/registrar.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# The per-Runtime registrar extension blocks run against. Seams are added one
+# at a time; today only #tool exists.
+class Riffer::Rig::Registrar
+  # @rbs @tools: Array[singleton(Riffer::Tool)]
+
+  # @rbs return: void
+  def initialize
+    @tools = []
+  end
+
+  # @rbs klass: singleton(Riffer::Tool)
+  # @rbs return: void
+  def tool(klass)
+    @tools << klass
+  end
+
+  # @rbs return: Array[singleton(Riffer::Tool)]
+  def tools
+    @tools.dup
+  end
+end

data/lib/riffer/rig/repl.rb

@@ -11,28 +11,28 @@ class Riffer::Rig::REPL
   # @rbs @smoother: Riffer::Rig::UI::Smoother
   # @rbs @cursor: Riffer::Rig::UI::Cursor
   # @rbs @theme: Riffer::Rig::UI::Theme
-  # @rbs @input: untyped
-  # @rbs @output: untyped
-
-  # @rbs ?agent: Riffer::Agent
-  # @rbs ?renderer: Riffer::Rig::UI::Renderer
-  # @rbs input: untyped
-  # @rbs output: untyped
-  # @rbs ?theme: Riffer::Rig::UI::Theme
-  # @rbs ?animator: Riffer::Rig::UI::Animator
-  # @rbs ?smoother: Riffer::Rig::UI::Smoother
-  # @rbs ?cursor: Riffer::Rig::UI::Cursor
+  # @rbs @input: IO
+  # @rbs @output: IO
+
+  # @rbs agent: Riffer::Agent
+  # @rbs renderer: Riffer::Rig::UI::Renderer
+  # @rbs input: IO
+  # @rbs output: IO
+  # @rbs theme: Riffer::Rig::UI::Theme
+  # @rbs animator: Riffer::Rig::UI::Animator
+  # @rbs smoother: Riffer::Rig::UI::Smoother
+  # @rbs cursor: Riffer::Rig::UI::Cursor
   # @rbs return: void
-  def initialize(agent:, renderer:, input: $stdin, output: $stdout, theme: Riffer::Rig::UI::Theme.for(output),
-                 animator: Riffer::Rig::UI::Animator.new(
-                   io: output,
-                   theme:
-                 ), smoother: Riffer::Rig::UI::Smoother.new(
-                   io: output,
-                   theme:
-                 ), cursor: Riffer::Rig::UI::Cursor.new(
-                   io: output, theme:
-                 ))
+  def initialize(
+    agent:,
+    renderer:,
+    input: $stdin,
+    output: $stdout,
+    theme: Riffer::Rig::UI::Theme.for(output),
+    animator: Riffer::Rig::UI::Animator.new(io: output, theme:),
+    smoother: Riffer::Rig::UI::Smoother.new(io: output, theme:),
+    cursor: Riffer::Rig::UI::Cursor.new(io: output, theme:)
+  )
     @agent = agent
     @renderer = renderer
     @animator = animator
@@ -74,14 +74,14 @@ class Riffer::Rig::REPL
   # @rbs return: void
   def run_turn(prompt)
     @cursor.hide
-    @animator.start
+    start_animator
     @smoother.start
     @agent.stream(prompt).each do |event|
       case event
       when Riffer::StreamEvents::ReasoningDelta
-        @animator.start(:reasoning)
+        start_animator(:reasoning)
       when Riffer::StreamEvents::ReasoningDone
-        @animator.start
+        start_animator
       when Riffer::StreamEvents::ToolCallDelta, Riffer::StreamEvents::FinishReasonDone
         next
       when Riffer::StreamEvents::SkillActivation
@@ -89,13 +89,13 @@ class Riffer::Rig::REPL
         # spinner comes straight back on to cover the silent stretch.
         @animator.stop
         @renderer.render(event)
-        @animator.start
+        start_animator
         next
       when Riffer::StreamEvents::TokenUsageDone
         # Usage renders nothing inline — it flushes below the turn's output.
         # Restarting here covers the silent tool-execution stretch that follows.
         @renderer.render(event)
-        @animator.start
+        start_animator
         next
       else
         @animator.stop
@@ -158,6 +158,7 @@ class Riffer::Rig::REPL
   # their line with a newline but leave the renderer's tool-group state alone —
   # they can only follow prose, never mid-group.
   #
+  # @rbs &block: () -> String
   # @rbs return: void
   def print_block(&)
     @output.puts
@@ -172,6 +173,17 @@ class Riffer::Rig::REPL
 
     @animator.stop
     @renderer.render_tool_result(message)
-    @animator.start
+    start_animator
+  end
+
+  # Every animator start sits behind a smoother drain: the smoother's backlog
+  # may still be trickling out from streamed prose, and spinner frames drawn
+  # mid-drain would carve `\r…\e[K` through a half-printed sentence.
+  #
+  # @rbs mode: Symbol
+  # @rbs return: void
+  def start_animator(mode = :neutral)
+    @smoother.drain
+    @animator.start(mode)
   end
 end

data/lib/riffer/rig/runtime.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'date'
+
+# One Runtime builds its own Riffer::Agent from a per-instance
+# Riffer::Agent::Config and runs a prompt: streamed as events, or run to
+# completion and returned as riffer's Agent::Response.
+#
+#   runtime = Riffer::Rig::Runtime.new('mock/x')
+#   runtime.prompt('hello') { |event| ... }   # yields riffer StreamEvents
+#   runtime.prompt('hello').each { |event| }  # an Enumerator without a block
+#   response = runtime.ask('hello')           # a Riffer::Agent::Response
+#
+# Two Runtimes in one process share nothing but the process-wide extension
+# registry and riffer's provider repository. One prompt runs at a time; a
+# second while one is running raises Riffer::Rig::Runtime::BusyError. The
+# Runtime never renders, never prints, never reads the filesystem.
+class Riffer::Rig::Runtime
+  # Raised when a second prompt, ask or registrar build runs while one is
+  # already running on this Runtime.
+  class BusyError < StandardError; end
+
+  BASE_PROMPT_TEMPLATE = <<~TEXT
+    You are %<name>s, a general-purpose agent. You work by using the tools you have
+    been given; each tool describes what it does and when to use it.
+
+    - Verify with your tools before answering. When a tool can settle a question,
+      look rather than guess.
+    - Do what was asked, and all of what was asked. Do not widen the scope, tidy
+      nearby things, or add extras that were not requested.
+    - Be concise. Lead with the outcome; do not restate the question.
+  TEXT
+
+  DEFAULT_NAME = 'riffer'
+
+  # The legacy CodingAgent's default: an unlimited agent loop. riffer's own
+  # default (16) is too small for a general-purpose harness.
+  DEFAULT_MAX_STEPS = nil #: Integer?
+
+  # @rbs!
+  #   interface _Host
+  #     def ask: (?String, ?options: Array[String]?, ?secret: bool) -> String?
+  #     def confirm: (?String) -> bool
+  #     def notify: (?String, ?level: Symbol) -> void
+  #     def progress: (?String) { () -> void } -> void
+  #     def capabilities: () -> Set[Symbol]
+  #   end
+
+  # @rbs @agent: Riffer::Agent
+  # @rbs @cwd: String
+  # @rbs @host: _Host
+  # @rbs @settings: Hash[Symbol, untyped]
+  # @rbs @busy: bool
+  # @rbs @registrar: Riffer::Rig::Registrar
+
+  # @dynamic agent, cwd, host, settings
+  attr_reader :agent #: Riffer::Agent
+  attr_reader :cwd #: String
+  attr_reader :host #: _Host
+  attr_reader :settings #: Hash[Symbol, untyped]
+
+  # @rbs model: String
+  # @rbs extensions: Array[Riffer::Rig::Extension]
+  # @rbs tools: Array[String]?
+  # @rbs settings: Hash[Symbol, untyped]
+  # @rbs host: _Host
+  # @rbs cwd: String?
+  # @rbs name: String
+  # @rbs instructions: String?
+  # @rbs credentials: Hash[String, String]
+  # @rbs pricing: Hash[String, Riffer::Rig::Settings::Pricing]
+  # @rbs max_steps: Integer?
+  # @rbs snapshot: Hash[Symbol, untyped]?
+  # @rbs return: void
+  def initialize(
+    model,
+    extensions: [],
+    tools: nil,
+    settings: {},
+    host: Riffer::Rig::Host.new,
+    cwd: nil,
+    name: DEFAULT_NAME,
+    instructions: nil,
+    credentials: {},
+    pricing: {},
+    max_steps: DEFAULT_MAX_STEPS,
+    snapshot: nil
+  )
+    @host = host
+    @cwd = cwd || Dir.pwd
+    @settings = settings
+
+    @busy = false
+    @registrar = build_registrar(extensions)
+    tool_classes = select_tools(@registrar.tools, tools)
+    base_prompt = instructions || format(BASE_PROMPT_TEMPLATE, name: name)
+
+    @agent = Riffer::Agent.new(
+      config: Riffer::Agent::Config.new(
+        model: model,
+        instructions: system_prompt(base_prompt),
+        tools_config: tool_classes,
+        max_steps: max_steps
+      )
+    )
+  end
+
+  # @rbs text: String
+  # @rbs &block: ?(Riffer::StreamEvents::Base) -> void
+  # @rbs return: (nil | Enumerator[Riffer::StreamEvents::Base, void])
+  def prompt(text, &block)
+    raise BusyError, 'a prompt is already running on this Runtime' if @busy
+
+    @busy = true
+    if block
+      @agent.stream(text).each(&block)
+      nil
+    else
+      @agent.stream(text)
+    end
+  ensure
+    @busy = false
+  end
+
+  # @rbs text: String
+  # @rbs return: Riffer::Agent::Response
+  def ask(text)
+    raise BusyError, 'a prompt is already running on this Runtime' if @busy
+
+    @busy = true
+    @agent.stream(text).each { |event| event }
+  ensure
+    @busy = false
+  end
+
+  private
+
+  # @rbs extensions: Array[Riffer::Rig::Extension]
+  # @rbs return: Riffer::Rig::Registrar
+  def build_registrar(extensions)
+    raise BusyError, 'a prompt is already running on this Runtime' if @busy
+
+    extensions.each_with_object(Riffer::Rig::Registrar.new) do |extension, registrar|
+      extension.run(registrar)
+    end
+  end
+
+  # @rbs registered: Array[singleton(Riffer::Tool)]
+  # @rbs allowlist: Array[String]?
+  # @rbs return: Array[singleton(Riffer::Tool)]
+  def select_tools(registered, allowlist)
+    return registered if allowlist.nil?
+
+    registered.select { |klass| allowlist.include?(klass.name) }
+  end
+
+  # @rbs base_prompt: String
+  # @rbs return: String
+  def system_prompt(base_prompt)
+    "#{base_prompt}\n\nCurrent date: #{Date.today}\nCurrent working directory: #{@cwd}"
+  end
+end

data/lib/riffer/rig/settings/document.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Settings::Document
+  # @rbs @model: String?
+  # @rbs @reasoning: String?
+  # @rbs @models: Hash[String, Riffer::Rig::Settings::Pricing]
+
+  # @dynamic model, reasoning, models
+  attr_reader :model #: String?
+  attr_reader :reasoning #: String?
+  attr_reader :models #: Hash[String, Riffer::Rig::Settings::Pricing]
+
+  # @rbs source: untyped
+  # @rbs return: void
+  def initialize(source)
+    @model = source['model'].is_a?(String) ? source['model'] : nil
+    @reasoning = source['reasoning'].is_a?(String) ? source['reasoning'] : nil
+    entries = source['models'].is_a?(Hash) ? source['models'] : {} #: Hash[String, untyped]
+    @models = entries.filter_map do |name, entry|
+      [name, Riffer::Rig::Settings::Pricing.from(entry)] if name.is_a?(String) && entry.is_a?(Hash)
+    end.to_h
+  end
+end

data/lib/riffer/rig/settings/pricing.rb

@@ -5,6 +5,17 @@ class Riffer::Rig::Settings::Pricing
   # @dynamic input, output, cache_write, cache_read
   attr_reader :input, :output, :cache_write, :cache_read #: Float
 
+  # @rbs entry: Hash[String, untyped]
+  # @rbs return: ::Riffer::Rig::Settings::Pricing
+  def self.from(entry)
+    new(
+      input: entry.fetch('input', 0).to_f,
+      output: entry.fetch('output', 0).to_f,
+      cache_write: entry.fetch('cache_write', 0).to_f,
+      cache_read: entry.fetch('cache_read', 0).to_f
+    )
+  end
+
   # @rbs input: Float
   # @rbs output: Float
   # @rbs cache_write: Float

data/lib/riffer/rig/settings.rb

@@ -51,7 +51,7 @@ module Riffer::Rig::Settings
   # @rbs path: String
   # @rbs return: String
   def model(path: PATH)
-    read(path).fetch('model', DEFAULT_MODEL)
+    read(path).model || DEFAULT_MODEL
   end
 
   # Returns model options for the configured model and reasoning level, ready
@@ -80,15 +80,7 @@ module Riffer::Rig::Settings
   # @rbs path: String
   # @rbs return: Pricing?
   def pricing_for(model, path: PATH)
-    entry = read(path).dig('models', model)
-    return nil unless entry.is_a?(Hash)
-
-    Pricing.new(
-      input: entry.fetch('input', 0).to_f,
-      output: entry.fetch('output', 0).to_f,
-      cache_write: entry.fetch('cache_write', 0).to_f,
-      cache_read: entry.fetch('cache_read', 0).to_f
-    )
+    read(path).models[model]
   end
 
   private
@@ -102,10 +94,10 @@ module Riffer::Rig::Settings
   end
 
   # @rbs path: String
-  # @rbs ?provider: String?
+  # @rbs provider: String?
   # @rbs return: String?
   def reasoning_for(path: PATH, provider: nil)
-    level = read(path)['reasoning']
+    level = read(path).reasoning
     valid_levels = (provider && REASONING_LEVELS_BY_PROVIDER[provider]) || []
     valid_levels.include?(level) ? level : nil
   end
@@ -129,16 +121,16 @@ module Riffer::Rig::Settings
     end
   end
 
-  # The parsed settings file, or an empty hash when the file is absent or
+  # The parsed settings file, or an empty document when the file is absent or
   # malformed.
   #
   # @rbs path: String
-  # @rbs return: Hash[String, untyped]
+  # @rbs return: Document
   def read(path)
-    return {} unless File.file?(path)
+    return Document.new({}) unless File.file?(path)
 
-    JSON.parse(File.read(path))
+    Document.new(JSON.parse(File.read(path)))
   rescue JSON::ParserError
-    {}
+    Document.new({})
   end
 end

data/lib/riffer/rig/token_tally.rb

@@ -22,7 +22,7 @@ class Riffer::Rig::TokenTally
   # @dynamic input_tokens, output_tokens, cache_write_tokens, cache_read_tokens
   attr_reader :input_tokens, :output_tokens, :cache_write_tokens, :cache_read_tokens
 
-  # @rbs ?pricing: Riffer::Rig::Settings::Pricing?
+  # @rbs pricing: Riffer::Rig::Settings::Pricing?
   # @rbs return: void
   def initialize(pricing: nil)
     @pricing = pricing

data/lib/riffer/rig/tools/bash.rb

@@ -23,7 +23,7 @@ class Riffer::Rig::Tools::Bash < Riffer::Tool
 
   # @rbs context: Riffer::Agent::Context?
   # @rbs command: String
-  # @rbs ?timeout_ms: Integer
+  # @rbs timeout_ms: Integer
   # @rbs return: Riffer::Tools::Response
   def call(context:, command:, timeout_ms: DEFAULT_TIMEOUT_MS)
     output, status = run(command, timeout_ms / 1000.0)

data/lib/riffer/rig/tools/edit.rb

@@ -19,7 +19,7 @@ class Riffer::Rig::Tools::Edit < Riffer::Tool
   # @rbs path: String
   # @rbs old_string: String
   # @rbs new_string: String
-  # @rbs ?replace_all: bool
+  # @rbs replace_all: bool
   # @rbs return: Riffer::Tools::Response
   def call(context:, path:, old_string:, new_string:, replace_all: false)
     resolved = File.expand_path(path, Dir.pwd)

data/lib/riffer/rig/tools/read.rb

@@ -15,8 +15,8 @@ class Riffer::Rig::Tools::Read < Riffer::Tool
 
   # @rbs context: Riffer::Agent::Context?
   # @rbs path: String
-  # @rbs ?offset: Integer?
-  # @rbs ?limit: Integer
+  # @rbs offset: Integer?
+  # @rbs limit: Integer
   # @rbs return: Riffer::Tools::Response
   def call(context:, path:, offset: nil, limit: DEFAULT_LIMIT)
     resolved = File.expand_path(path, Dir.pwd)