riffer-rig 0.7.0 → 0.9.0

data/lib/riffer/rig/runtime.rb

@@ -29,6 +29,15 @@ class Riffer::Rig::Runtime
 
   INTERRUPT_CANCELLED = :cancelled #: Symbol
 
+  # Upstream candidate: riffer's Anthropic, OpenAI and Azure OpenAI classes read
+  # the web_search option and OpenRouter passes unknown options through to its
+  # API, but the provider seam cannot yet answer which provider takes which
+  # option, so rig keeps the mapping until it can. Mock consumes web_search, so
+  # tests and embedders can exercise the switches.
+  NATIVE_TOOLS_BY_PROVIDER = {
+    web_search: { anthropic: true, openai: true, azure_openai: true, mock: true }.freeze
+  }.freeze #: Hash[Symbol, Hash[Symbol, bool]]
+
   # @rbs @agent: Riffer::Agent
   # @rbs @base_prompt: String
   # @rbs @cancel_flag: Riffer::Rig::Runtime::CancelFlag
@@ -43,8 +52,12 @@ class Riffer::Rig::Runtime
   # @rbs @session_start_reason: Symbol
   # @rbs @model_override: String?
   # @rbs @message_observers: Array[^(Riffer::Messages::Base) -> void]
+  # @rbs @model_observers: Array[^(String) -> void]
   # @rbs @prompts: Hash[Symbol, ^(Riffer::Rig::Runtime) -> String?]
   # @rbs @commands: Hash[String, Riffer::Rig::Command]
+  # @rbs @core_commands: Array[Riffer::Rig::Command]
+  # @rbs @claim_depth: Integer
+  # @rbs @claim_thread: Thread?
   # @rbs @declared_settings: Hash[String, Hash[Symbol, untyped]]
   # @rbs @errors: Array[Riffer::Rig::Extension::Failure]
   # @rbs @hooks: Riffer::Rig::Runtime::Hooks
@@ -52,6 +65,7 @@ class Riffer::Rig::Runtime
   # @rbs @mcp_registry: Riffer::Rig::Mcp::_Registry
   # @rbs @mcp_servers: Hash[String, Riffer::Rig::Mcp::Server]
   # @rbs @model_options: Hash[Symbol, untyped]
+  # @rbs @native_tools: Hash[Symbol, untyped]
 
   # @dynamic agent, credentials, cwd, host, id, settings, declared_settings
   attr_reader :agent #: Riffer::Agent
@@ -76,6 +90,7 @@ class Riffer::Rig::Runtime
   # @rbs mcp_registry: Riffer::Rig::Mcp::_Registry
   # @rbs max_steps: Integer?
   # @rbs model_options: Hash[Symbol, untyped]
+  # @rbs native_tools: Hash[Symbol, untyped]
   # @rbs snapshot: Hash[Symbol, untyped]?
   # @rbs return: void
   def initialize(
@@ -93,6 +108,7 @@ class Riffer::Rig::Runtime
     mcp_registry: Riffer::Mcp,
     max_steps: DEFAULT_MAX_STEPS,
     model_options: {},
+    native_tools: {},
     snapshot: nil
   )
     # Doubles as the snapshot id and ACP sessionId.
@@ -103,14 +119,19 @@ class Riffer::Rig::Runtime
 
     @busy = false
     @closed = false
+    @claim_depth = 0
+    @claim_thread = nil
+    @core_commands = []
     @cancel_flag = Riffer::Rig::Runtime::CancelFlag.new
     @session_start_pending = true
     @session_start_reason = snapshot ? :restore : :new
     @message_observers = []
+    @model_observers = []
     Riffer::Rig::Settings::Pricing.register(pricing, riffer_config.pricing)
     @errors = []
     @tool_allowlist = tools
-    @model_options = model_options
+    @native_tools = native_tools
+    @model_options = model_options.merge(native_options(model))
     @base_prompt = instructions || format(BASE_PROMPT_TEMPLATE, name: name)
     @mcp_registry = mcp_registry
     @mcp_servers = {}
@@ -136,7 +157,7 @@ class Riffer::Rig::Runtime
         turn(text)
       end
     ensure
-      @busy = false
+      release
     end
   end
 
@@ -147,7 +168,7 @@ class Riffer::Rig::Runtime
     begin
       turn(text).each { |event| event }
     ensure
-      @busy = false
+      release
     end
   end
 
@@ -156,6 +177,16 @@ class Riffer::Rig::Runtime
     @commands.values
   end
 
+  # Installs a host-of-the-runtime command (the Loader's /reload) so it
+  # survives every rebuild; an extension command of the same name replaces it.
+  # @rbs command: Riffer::Rig::Command
+  # @rbs return: nil
+  def install_command(command)
+    @core_commands << command
+    @commands[command.name] = command
+    nil
+  end
+
   # @rbs name: String
   # @rbs args: String
   # @rbs &block: ?(::Riffer::StreamEvents::Base | Riffer::Rig::Events::_Event) -> void
@@ -166,7 +197,7 @@ class Riffer::Rig::Runtime
     begin
       execute(name, args, emit)
     ensure
-      @busy = false
+      release
     end
     @host.drain.each(&emit)
     nil
@@ -187,15 +218,25 @@ class Riffer::Rig::Runtime
   def model=(model)
     # Upstream candidate: riffer resolves the model Proc once, in Agent.new, so
     # a switch rebuilds the agent over the same session and config.
-    @agent = successor(model, @agent.config)
+    agent = successor(model, @agent.config)
+    rederive_options(model)
+    @agent = agent
     @model_override = model
+    @model_observers.each { |observer| observer.call(model) }
+  end
+
+  # @rbs provider: Symbol
+  # @rbs values: Hash[Symbol, String]
+  # @rbs return: void
+  def merge_credentials(provider, values)
+    @credentials = @credentials.merge(provider => values)
   end
 
   # @rbs extensions: Array[Riffer::Rig::Extension]
   # @rbs settings: Hash[Symbol, untyped]
   # @rbs return: nil
   def rebuild(extensions:, settings:)
-    claim
+    claim_rebuild
     begin
       registrars = build_registrars(extensions, settings) { |_extension, error| raise error }
       mcp_servers = register_mcp_servers(registrars)
@@ -208,7 +249,7 @@ class Riffer::Rig::Runtime
       unregister_mcp_servers(dropped)
       lifecycle(:session_start, Riffer::Rig::Events::SessionStart.new(@id, :reload))
     ensure
-      @busy = false
+      release
     end
     nil
   end
@@ -225,6 +266,13 @@ class Riffer::Rig::Runtime
     nil
   end
 
+  # @rbs &block: (String) -> void
+  # @rbs return: nil
+  def on_model_change(&block)
+    @model_observers << block
+    nil
+  end
+
   # @rbs return: nil
   def cancel
     @cancel_flag.set
@@ -255,6 +303,31 @@ class Riffer::Rig::Runtime
     raise ClosedError, 'this Runtime is closed' if @closed
 
     @busy = true
+    @claim_depth += 1
+    @claim_thread = Thread.current
+  end
+
+  # Rebuild is a configuration swap at a quiet boundary, not a turn entry, so
+  # it may run nested under the thread that holds the Runtime — the /reload
+  # command and the automatic reload check both do. Another thread is still
+  # refused while work runs.
+  # @rbs return: void
+  def claim_rebuild
+    raise BusyError, 'a prompt is already running on this Runtime' if @busy && @claim_thread != Thread.current
+    raise ClosedError, 'this Runtime is closed' if @closed
+
+    @busy = true
+    @claim_depth += 1
+    @claim_thread = Thread.current
+  end
+
+  # @rbs return: void
+  def release
+    @claim_depth -= 1
+    return if @claim_depth.positive?
+
+    @busy = false
+    @claim_thread = nil
   end
 
   # @rbs model: String
@@ -275,6 +348,33 @@ class Riffer::Rig::Runtime
     agent
   end
 
+  # The options the settings built for the starting model are provider-shaped
+  # (cache control, per-provider reasoning levels), so a switch re-derives them.
+  # Runs after the successor is built, so a failed build leaves the running
+  # agent's options alone; riffer reads config.model_options per request, so the
+  # swap still reaches the new agent through the shared config.
+  # @rbs model: String
+  # @rbs return: void
+  def rederive_options(model)
+    reasoning = Riffer::Rig::Settings::Document.new(@settings).reasoning
+    @model_options = Riffer::Rig::Settings.model_options(model, reasoning).merge(native_options(model))
+    @agent.config.model_options = @model_options
+  end
+
+  # The switches are on/off settings, so what the agent can do stays a function
+  # of the current provider: a switch whose provider cannot take the option
+  # contributes nothing, and a switch to such a provider drops it, both silently.
+  # @rbs model: String
+  # @rbs return: Hash[Symbol, untyped]
+  def native_options(model)
+    provider = Riffer::Rig::Settings.provider_for(model)&.to_sym
+    @native_tools.filter_map do |tool, switch|
+      next unless provider && NATIVE_TOOLS_BY_PROVIDER[tool]&.key?(provider)
+
+      [tool, switch]
+    end.to_h
+  end
+
   # @rbs registrars: Array[Riffer::Rig::Registrar]
   # @rbs hooks: Riffer::Rig::Runtime::Hooks
   # @rbs max_steps: Numeric?
@@ -321,6 +421,8 @@ class Riffer::Rig::Runtime
     @prompts = registrars.flat_map { |registrar| registrar.prompts.to_a }.to_h
     skills = agent.context.skills&.skills&.values || []
     commands = [
+      *@core_commands,
+      Riffer::Rig::Commands::Auth.command,
       Riffer::Rig::Commands::Model.command,
       *skills.map { |skill| Riffer::Rig::Commands::Skill.command(skill) },
       *registrars.flat_map { |registrar| registrar.commands.values }
@@ -545,7 +647,7 @@ class Riffer::Rig::Runtime
   def build_registrars(extensions, settings)
     extensions.filter_map do |extension|
       registrar = Riffer::Rig::Registrar.new(extension.name, settings[extension.name.to_sym] || {})
-      error = load_extension(extension, registrar)
+      error = extension.load_into(registrar)
       next registrar unless error
 
       yield(extension, error)
@@ -553,19 +655,6 @@ class Riffer::Rig::Runtime
     end
   end
 
-  # @rbs extension: Riffer::Rig::Extension
-  # @rbs registrar: Riffer::Rig::Registrar
-  # @rbs return: StandardError?
-  def load_extension(extension, registrar)
-    rejection = extension.mismatch || registrar.collision
-    return rejection if rejection
-
-    extension.run(registrar)
-    nil
-  rescue StandardError => e
-    e
-  end
-
   # @rbs extension: Riffer::Rig::Extension
   # @rbs error: StandardError
   # @rbs return: void

data/lib/riffer/rig/sdk.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::SDK
+  extend self
+
+  CONFIRM_QUESTION = 'Install the %s gem now?' #: String
+
+  PROGRESS_LABEL = 'Installing %s %s' #: String
+
+  BUNDLER_MESSAGE = "%s is not installed and Bundler manages the load path; add gem '%s', '%s' to the Gemfile" #: String
+
+  DECLINED_MESSAGE = "%s is not installed; install it with gem install %s -v '%s' or add it to a Gemfile" #: String
+
+  FAILED_MESSAGE = '%s was installed but could not be loaded' #: String
+
+  private_constant :CONFIRM_QUESTION, :PROGRESS_LABEL, :BUNDLER_MESSAGE, :DECLINED_MESSAGE, :FAILED_MESSAGE
+
+  # @rbs gem: String
+  # @rbs requirement: String
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs return: String?
+  def ensure(gem, requirement, host:)
+    return nil if installed?(gem, requirement) && require_gem(gem)
+    return format(BUNDLER_MESSAGE, gem, gem, requirement) if bundler?
+
+    return format(DECLINED_MESSAGE, gem, gem, requirement) unless host.confirm(format(CONFIRM_QUESTION, gem))
+
+    host.progress(format(PROGRESS_LABEL, gem, requirement)) do
+      Gem.install(gem, Gem::Requirement.new(requirement))
+      Gem.clear_paths
+    end
+    return nil if require_gem(gem)
+
+    format(FAILED_MESSAGE, gem)
+  end
+
+  private
+
+  # @rbs gem: String
+  # @rbs requirement: String
+  # @rbs return: bool
+  def installed?(gem, requirement)
+    Gem::Specification.find_by_name(gem, requirement)
+    true
+  rescue Gem::LoadError
+    false
+  end
+
+  # @rbs gem: String
+  # @rbs return: bool
+  def require_gem(gem)
+    require gem
+    true
+  rescue ::LoadError
+    false
+  end
+
+  # @rbs return: bool
+  def bundler?
+    !defined?(Bundler).nil?
+  end
+end

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

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 class Riffer::Rig::Settings::Document
-  # @dynamic model, reasoning, models, providers, disabled
+  # @dynamic model, reasoning, models, providers, disabled, autoload, native_tools, save
   attr_reader :model #: String?
   attr_reader :reasoning #: String?
   attr_reader :models #: Hash[String, Riffer::Rig::Settings::Pricing]
   attr_reader :providers #: Hash[String, Hash[String, String]]
   attr_reader :disabled #: Array[String]
+  attr_reader :autoload #: bool
+  attr_reader :native_tools #: Hash[Symbol, bool | Hash[Symbol, untyped]]
+  attr_reader :save #: bool
 
   # @rbs source: Hash[Symbol, untyped]
   # @rbs return: void
@@ -26,6 +29,11 @@ class Riffer::Rig::Settings::Document
     disabled = hash_or_empty(source[:extensions])[:disabled]
     names = disabled.is_a?(Array) ? disabled.grep(String) : [] #: Array[String]
     @disabled = names.freeze
+    @autoload = hash_or_empty(source[:extensions])[:autoload] == true
+    @save = hash_or_empty(source[:sessions])[:save] != false
+    @native_tools = hash_or_empty(hash_or_empty(source[:tools])[:native])
+                    .select { |_tool, switch| switch == true || switch.is_a?(Hash) }
+                    .transform_keys(&:to_sym).freeze
     freeze
   end
 

data/lib/riffer/rig/settings.rb

@@ -16,9 +16,10 @@ module Riffer::Rig::Settings
 
   MODEL_STRING = %r{\A(?<provider>[^/\s]+)/\S+\z} #: Regexp
 
-  # Upstream candidate: riffer's Repository keeps extension registrations
-  # private and lists no identifiers, so the list names riffer's built-ins.
-  PROVIDERS = (Riffer::Providers::Repository::REPO.keys - [:mock]).freeze #: Array[Symbol]
+  # @rbs return: Array[Symbol]
+  def providers
+    Riffer::Rig::Providers.identifiers
+  end
 
   # @rbs path: String
   # @rbs return: Hash[Symbol, untyped]
@@ -62,7 +63,7 @@ module Riffer::Rig::Settings
     provider = provider_for(model)
     return if provider && Riffer::Providers::Repository.find(provider)
 
-    "#{model} is not a provider/name model string; the provider is one of: #{PROVIDERS.join(', ')}"
+    "#{model} is not a provider/name model string; the provider is one of: #{providers.join(', ')}"
   end
 
   # @rbs model: String

data/lib/riffer/rig/stores/jsonl.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+
+class Riffer::Rig::Stores::JSONL
+  HEADER_VERSION = 1 #: Integer
+
+  # @rbs @home: String
+  # @rbs @paths: Hash[String, String]
+
+  # @rbs home: String
+  # @rbs return: void
+  def initialize(home: Dir.home)
+    @home = home
+    @paths = {}
+  end
+
+  # @rbs id: String
+  # @rbs entry: Hash[Symbol, untyped]
+  # @rbs return: void
+  def append(id, entry)
+    File.write(path_for(id, entry), "#{JSON.generate(entry)}\n", mode: 'a')
+  end
+
+  # @rbs id: String
+  # @rbs return: Array[Hash[Symbol, untyped]]
+  def read(id)
+    path = find(id)
+    return [] unless path
+
+    File.foreach(path).filter_map { |line| parse(line) }
+  end
+
+  # @rbs cwd: String?
+  # @rbs return: Array[Hash[Symbol, untyped]]
+  def list(cwd: nil)
+    headers = Dir.glob(File.join(root, '*', '*.jsonl')).filter_map { |path| header_of(path) }
+    cwd ? headers.select { |header| header[:cwd] == cwd } : headers
+  end
+
+  # @rbs id: String
+  # @rbs return: void
+  def delete(id)
+    path = find(id)
+    return unless path
+
+    File.delete(path)
+    @paths.delete(id)
+  end
+
+  private
+
+  # @rbs return: String
+  def root
+    File.join(@home, '.riffer', 'sessions')
+  end
+
+  # @rbs id: String
+  # @rbs entry: Hash[Symbol, untyped]
+  # @rbs return: String
+  def path_for(id, entry)
+    @paths.fetch(id) do
+      path = entry[:type] == 'header' ? new_path(id, entry.fetch(:cwd)) : find(id)
+      raise ArgumentError, "no session file for #{id}" unless path
+
+      @paths[id] = path
+    end
+  end
+
+  # @rbs id: String
+  # @rbs cwd: String
+  # @rbs return: String
+  def new_path(id, cwd)
+    dir = File.join(root, slug(cwd))
+    FileUtils.mkdir_p(dir)
+    File.join(dir, "#{id}.jsonl")
+  end
+
+  # @rbs path: String
+  # @rbs return: Hash[Symbol, untyped]?
+  def header_of(path)
+    line = File.foreach(path).first
+    entry = parse(line) if line
+    entry if entry.is_a?(Hash) && entry[:type] == 'header'
+  end
+
+  # @rbs id: String
+  # @rbs return: String?
+  def find(id)
+    @paths.fetch(id) do
+      found = Dir.glob(File.join(root, '*', "#{id}.jsonl")).first
+      @paths[id] = found if found
+      found
+    end
+  end
+
+  # The slug groups a cwd's sessions for listing; it is not the truth — the
+  # header's cwd is, so two cwd strings that slug alike share a directory. A
+  # bare "." or ".." is collapsed so the file stays inside the sessions tree.
+  # @rbs cwd: String
+  # @rbs return: String
+  def slug(cwd)
+    slug = cwd.gsub(/[^A-Za-z0-9._-]+/, '-').gsub(/\A-+|-+\z/, '')
+    slug.empty? || slug.match?(/\A\.{1,2}\z/) ? '-' : slug
+  end
+
+  # @rbs line: String
+  # @rbs return: Hash[Symbol, untyped]?
+  def parse(line)
+    JSON.parse(line, symbolize_names: true)
+  rescue JSON::ParserError
+    nil
+  end
+end

data/lib/riffer/rig/stores/recorder.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'time'
+
+class Riffer::Rig::Stores::Recorder
+  EXTENSION_NAME = 'session-store' #: String
+
+  # @rbs @store: Riffer::Rig::Stores::_Store
+  # @rbs @runtime: Riffer::Rig::Runtime?
+  # @rbs @header_written: bool
+  # @rbs @pending: Array[Hash[Symbol, untyped]]
+  # @rbs @title: String?
+
+  # Records one Loader-built session into the store: the header on the first
+  # message (its title needs the first prompt), one entry per message, one per
+  # model switch and one per skill activation. Entries that land before the
+  # first message (a /model before the first prompt) wait for the header.
+  # @rbs store: Riffer::Rig::Stores::_Store
+  # @rbs return: void
+  def initialize(store:)
+    @store = store
+    @runtime = nil
+    @header_written = false
+    @pending = []
+    @title = nil
+  end
+
+  # @rbs runtime: Riffer::Rig::Runtime
+  # @rbs return: void
+  def attach(runtime)
+    @runtime = runtime
+    runtime.on_message { |message| message(message) }
+    runtime.on_model_change { |model| switched(model) }
+  end
+
+  # @rbs event: Riffer::StreamEvents::SkillActivation
+  # @rbs return: void
+  def skill(event)
+    record(type: 'skill', skill: event.name)
+  end
+
+  # @rbs message: Riffer::Messages::Base
+  # @rbs return: void
+  def message(message)
+    @title ||= one_line(message.content) if message.is_a?(Riffer::Messages::User)
+    write_header unless @header_written
+    record(type: 'message', message: message.to_h)
+  end
+
+  # @rbs model: String
+  # @rbs return: void
+  def switched(model)
+    record(type: 'model', model: model)
+  end
+
+  # The extension rides the build as its last extension, so its :stream hook
+  # sees the model's skill activations. Per build, unlike the extensions in
+  # the process registry: the hook closes over this build's recorder.
+  # @rbs recorder: Riffer::Rig::Stores::Recorder
+  # @rbs return: Riffer::Rig::Extension
+  def self.extension(recorder)
+    Riffer::Rig::Extension.new(EXTENSION_NAME) do |registrar|
+      registrar.on(:stream) do |event|
+        case event
+        when Riffer::StreamEvents::SkillActivation then recorder.skill(event)
+        end
+      end
+    end
+  end
+
+  private
+
+  # @rbs entry: Hash[Symbol, untyped]
+  # @rbs return: void
+  def record(entry)
+    unless @header_written
+      @pending << entry
+      return
+    end
+
+    @store.append(runtime.id, entry)
+  end
+
+  # @rbs return: void
+  def write_header
+    @header_written = true
+    @store.append(runtime.id, header_entry)
+    @pending.each { |entry| @store.append(runtime.id, entry) }
+    @pending.clear
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def header_entry
+    {
+      type: 'header',
+      schema_version: Riffer::Rig::Stores::JSONL::HEADER_VERSION,
+      id: runtime.id,
+      cwd: runtime.cwd,
+      created_at: Time.now.utc.iso8601,
+      model: runtime.model,
+      riffer_rig_version: Riffer::Rig::VERSION,
+      riffer_version: Riffer::VERSION,
+      title: @title.to_s
+    }
+  end
+
+  # @rbs content: String
+  # @rbs return: String
+  def one_line(content)
+    content.lines.first.to_s.strip
+  end
+
+  # The recorder is built before the Runtime it records; every entry arrives
+  # after attach, so the runtime is always there by then.
+  # @rbs return: Riffer::Rig::Runtime
+  def runtime
+    @runtime || raise(StandardError, 'Recorder used before attach')
+  end
+end