riffer-rig 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d560ab0c2be62a87e8468ba302f443985cd5d92d4872de2073c5c77b672d83f
-  data.tar.gz: b75fe6a3d1a7f0c718405f619f2f56c20fe85282ddb94aff9c2beb853344c119
+  metadata.gz: 0bc260756e56f8ed0d89556ef071a3ecb1922b637eb5b10cc0268416e0ceb26d
+  data.tar.gz: b7e6d6314a893ff23f289336b5e3df25f11e032f060272d7656695f1e96e584d
 SHA512:
-  metadata.gz: a2ca46037680a034a31b977101a9c5b442fc21f56842cb3055f2163493d42eef2d92ccdbc53aa9bf5fd2749af6fcfd52fb6d74aecbea0da907a5bac3ecee7498
-  data.tar.gz: 4e531d3fee7fa1107e7d6a7c5d1fa064c4bbdf9e46763353332d4b9d9b57b6a37436d54326fe06e21248c147d99e15ddaac4a18b6ee8ffd34be4e29d733444ae
+  metadata.gz: edda5ec3d1675966361db52a009328703f0f62340d8d18ea3f5e689f3e9194762fec33804072989f1cb92d357038e03ca9481e7ab9f34eb123964f3f025b8749
+  data.tar.gz: c1953f30afa3a7871291852d3aaeba52a256006732582c82f71ad3245234f1e2a974524b174a801df81096af6effc37186e3a10e11ace5f5be644edbe4ed1c49

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [0.10.0](https://github.com/bottrall/riffer-rig/compare/v0.9.0...v0.10.0) (2026-10-05)
+
+
+### Features
+
+* continue and resume sessions with -c and -r ([#220](https://github.com/bottrall/riffer-rig/issues/220)) ([e43d3ac](https://github.com/bottrall/riffer-rig/commit/e43d3ac44678e56016791545ea241779569687c9))
+* reload automatically before each request ([#222](https://github.com/bottrall/riffer-rig/issues/222)) ([fe96aa4](https://github.com/bottrall/riffer-rig/commit/fe96aa4476b0765e58824a8eb59301f0986e397c))
+
+## [0.9.0](https://github.com/bottrall/riffer-rig/compare/v0.8.0...v0.9.0) (2026-10-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* optional provider SDKs and the missing-SDK flow ([#211](https://github.com/bottrall/riffer-rig/issues/211))
+
+### Features
+
+* /auth lists, re-runs and removes provider credentials ([#213](https://github.com/bottrall/riffer-rig/issues/213)) ([ce17f15](https://github.com/bottrall/riffer-rig/commit/ce17f15286f5bc776775e1cbff4fb6db673379f7))
+* /model --save and provider switching through the Loader ([#214](https://github.com/bottrall/riffer-rig/issues/214)) ([f033caa](https://github.com/bottrall/riffer-rig/commit/f033caa6fc4b02b8a4429174f7d5256e4e7ece5b))
+* extension providers with a setup on the provider seam ([#216](https://github.com/bottrall/riffer-rig/issues/216)) ([f24f632](https://github.com/bottrall/riffer-rig/commit/f24f632f7f6a1a9903e1bdd0985076a1d03f12d3))
+* JSONL session store appends every Loader-built Runtime ([#219](https://github.com/bottrall/riffer-rig/issues/219)) ([67c5e80](https://github.com/bottrall/riffer-rig/commit/67c5e80efcea07b421b2c8512e576593d7a826d3))
+* optional provider SDKs and the missing-SDK flow ([#211](https://github.com/bottrall/riffer-rig/issues/211)) ([334c94b](https://github.com/bottrall/riffer-rig/commit/334c94bc4954f87846ead17a936690a40d847c75)), closes [#127](https://github.com/bottrall/riffer-rig/issues/127)
+* provider-native tools switched on in settings ([#217](https://github.com/bottrall/riffer-rig/issues/217)) ([6ba2a6a](https://github.com/bottrall/riffer-rig/commit/6ba2a6ad7ca0885af3e5c853786a0f3e22e0373a))
+* reload tracked files with /reload ([#218](https://github.com/bottrall/riffer-rig/issues/218)) ([403de96](https://github.com/bottrall/riffer-rig/commit/403de9645afd91082551a966d04cc18beeb8f194)), closes [#132](https://github.com/bottrall/riffer-rig/issues/132)
+
+
+### Bug Fixes
+
+* bundle provider SDKs for the checkout's bundler/setup ([#215](https://github.com/bottrall/riffer-rig/issues/215)) ([f0cc9e6](https://github.com/bottrall/riffer-rig/commit/f0cc9e6afcf82d1f006ab09679a4be38be846af2))
+
 ## [0.8.0](https://github.com/bottrall/riffer-rig/compare/v0.7.0...v0.8.0) (2026-10-02)
 
 

data/README.md

@@ -16,7 +16,13 @@ Install the gem:
 gem install riffer-rig
 ```
 
-This provides a `riffer` executable.
+This provides a `riffer` executable. No provider SDK is installed with it: `gemini/…` models work out of the box, and every other provider's SDK gem is either installed on its first use — `riffer-rig` asks, then installs it in-process — or added to a Gemfile ahead of time:
+
+```ruby
+gem 'anthropic', '~> 1.69'
+```
+
+[Providers](docs/PROVIDERS.md#sdk-gems) lists each provider's gem and how the install offer works.
 
 ## Usage
 
@@ -40,6 +46,9 @@ The model is the first of these that is set: `--model`, `RIFFER_MODEL`, `model`
 | `--no-agents-md`        | leaves out the [AGENTS.md](docs/INSTRUCTIONS.md#agentsmd) instructions      |
 | `--tools read,bash`     | only these tools, by identifier ([Tools](docs/TOOLS.md))                    |
 | `--max-steps N`         | stops a turn after `N` model calls                                          |
+| `--no-save`             | does not save this session to the [store](docs/SESSIONS.md)                 |
+| `-c`, `--continue`      | continues the most recent session in this directory ([Sessions](docs/SESSIONS.md#resuming)) |
+| `-r ID`, `--resume ID`  | resumes the session with id `ID` ([Sessions](docs/SESSIONS.md#resuming))    |
 | `-h`, `--help`          | prints the usage                                                            |
 
 `riffer -p` (one prompt, no terminal) and `riffer acp` (an editor's agent over stdio) are reserved: for now each prints the usage and exits with status 2.
@@ -82,9 +91,11 @@ Each value resolves on its own: environment variable first, then the stored valu
 
 The flat `{"anthropic": "sk-…"}` shape earlier versions wrote is no longer read; paste the key again when prompted. [Providers](docs/PROVIDERS.md) has the full format.
 
+Inside a session, `/auth` lists every provider with where its secret comes from — `env`, `stored`, `chain` (the SDK's own credential chain, for Bedrock) or `missing`. `/auth <provider>` re-runs that provider's setup, which is how you rotate a key, and applies the new values to the current session, so the next request uses them. `/auth remove <provider>` deletes the provider's `auth.json` entry and its `providers` block in settings.
+
 ### Switching the model
 
-`/model provider/name` switches the model for the current session only, keeping the conversation so far — `/model openai/gpt-5`, say. The provider prefix is required: a bare name such as `/model sonnet` is rejected with the list of providers. `/model` alone shows the model in use. The switch is refused when the session has no credentials for the new provider, and it never changes `settings.json`; set `model` there to change the model new sessions start with ([Configuration](docs/CONFIGURATION.md#model)).
+`/model provider/name` switches the model for the current session only, keeping the conversation so far — `/model openai/gpt-5`, say. The provider prefix is required: a bare name such as `/model sonnet` is rejected with the list of providers. `/model` alone shows the model in use. Switching runs the same setup for the new provider as startup does: its SDK gem is offered for install (or refused with the exact Gemfile line), and missing credentials are resolved — you are prompted for them when the host can ask, and the values apply to the running session immediately. The switch is refused with one error when the host cannot supply what is missing, and the model is left unchanged. `/model --save` writes the model in effect to the home `settings.json`, so new sessions start with it; `/model provider/name --save` switches and saves in one step, and a refused switch saves nothing ([Configuration](docs/CONFIGURATION.md#model)).
 
 ### Configuration
 

data/lib/riffer/rig/cli/flags.rb

@@ -9,11 +9,14 @@ class Riffer::Rig::CLI::Flags
            riffer acp           (not available yet)
   TEXT
 
-  # @dynamic model, extensions, skills, agents_md, tools, max_steps, help
+  # @dynamic model, extensions, skills, agents_md, tools, max_steps, help, save, continue, resume
   attr_reader :model #: String?
   attr_reader :extensions, :skills, :agents_md, :help #: bool
   attr_reader :tools #: Array[String]?
   attr_reader :max_steps #: Integer?
+  attr_reader :save #: bool
+  attr_reader :continue #: bool
+  attr_reader :resume #: String?
 
   # @rbs argv: Array[String]
   # @rbs return: Riffer::Rig::CLI::Flags | String
@@ -29,6 +32,9 @@ class Riffer::Rig::CLI::Flags
       agents_md: !values.key?(:'no-agents-md'),
       tools: values[:tools],
       max_steps: values[:'max-steps'],
+      save: !values.key?(:'no-save'),
+      continue: values.key?(:continue),
+      resume: values[:resume],
       help: values.key?(:help)
     )
   rescue OptionParser::ParseError => e
@@ -51,6 +57,9 @@ class Riffer::Rig::CLI::Flags
       parser.on('--no-agents-md', 'Leave out AGENTS.md instructions')
       parser.on('--tools NAME,NAME', Array, 'Only these tools, by identifier')
       parser.on('--max-steps N', Integer, 'Stop a turn after N model calls')
+      parser.on('--no-save', 'Do not save this session')
+      parser.on('-c', '--continue', 'Continue the most recent session in this directory')
+      parser.on('-r ID', '--resume ID', String, 'Resume the session with this id')
       parser.on('-h', '--help', 'Show this help')
     end
   end
@@ -62,15 +71,32 @@ class Riffer::Rig::CLI::Flags
   # @rbs agents_md: bool
   # @rbs tools: Array[String]?
   # @rbs max_steps: Integer?
+  # @rbs save: bool
+  # @rbs continue: bool
+  # @rbs resume: String?
   # @rbs help: bool
   # @rbs return: void
-  def initialize(model: nil, extensions: true, skills: true, agents_md: true, tools: nil, max_steps: nil, help: false)
+  def initialize(
+    model: nil,
+    extensions: true,
+    skills: true,
+    agents_md: true,
+    tools: nil,
+    max_steps: nil,
+    save: true,
+    continue: false,
+    resume: nil,
+    help: false
+  )
     @model = model
     @extensions = extensions
     @skills = skills
     @agents_md = agents_md
     @tools = tools&.freeze
     @max_steps = max_steps
+    @save = save
+    @continue = continue
+    @resume = resume
     @help = help
     freeze
   end

data/lib/riffer/rig/cli.rb

@@ -52,21 +52,53 @@ module Riffer::Rig::CLI
       version: Riffer::Rig::VERSION,
       no_color: env.is_a?(Riffer::Rig::Env) && env.no_color
     ).run do |host|
-      Riffer::Rig::Loader.runtime(
+      loader = Riffer::Rig::Loader.new(
         cwd: cwd,
         host: host,
         env: env,
         home: home,
-        model: flags.model,
-        extensions: flags.extensions,
-        skills: flags.skills,
-        agents_md: flags.agents_md,
-        tools: flags.tools,
-        max_steps: flags.max_steps
+        store: flags.save ? Riffer::Rig::Stores::JSONL.new : nil
       )
+      resumed(flags, host, loader) || build(loader, flags)
     end
   end
 
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs host: Riffer::Rig::Hosts::_Host
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs return: Riffer::Rig::Runtime?
+  def resumed(flags, host, loader)
+    if flags.resume
+      started = loader.resume(flags.resume, **keywords(flags))
+      host.notify("No saved session #{flags.resume}.") unless started
+      started
+    elsif flags.continue
+      started = loader.continue(**keywords(flags))
+      host.notify('No saved session in this directory.') unless started
+      started
+    end
+  end
+
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs return: Riffer::Rig::Runtime
+  def build(loader, flags)
+    loader.runtime(**keywords(flags))
+  end
+
+  # @rbs flags: Riffer::Rig::CLI::Flags
+  # @rbs return: Hash[Symbol, untyped]
+  def keywords(flags)
+    {
+      model: flags.model,
+      extensions: flags.extensions,
+      skills: flags.skills,
+      agents_md: flags.agents_md,
+      tools: flags.tools,
+      max_steps: flags.max_steps
+    }
+  end
+
   # @rbs name: String
   # @rbs error: IO
   # @rbs return: Integer

data/lib/riffer/rig/commands/auth.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Commands::Auth
+  extend self
+
+  USAGE = 'Use /auth, /auth <provider> or /auth remove <provider>' #: String
+
+  # @rbs return: Riffer::Rig::Command
+  def command
+    Riffer::Rig::Command.new(
+      'auth',
+      description: 'Show, re-run or remove provider credentials',
+      extension: 'core'
+    ) { |ctx| run(ctx) }
+  end
+
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs return: void
+  def run(ctx)
+    words = ctx.args.split
+    return ctx.say(list) if words.empty?
+    return remove(ctx, words[1]) if words[0] == 'remove' && words.length == 2
+    return rerun(ctx, words[0]) if words.length == 1
+
+    ctx.say(USAGE)
+  end
+
+  private
+
+  # @rbs return: String
+  def hint
+    'Use /auth <provider> or /auth remove <provider>, with a provider from: ' \
+      "#{Riffer::Rig::Settings.providers.join(', ')}"
+  end
+
+  # @rbs return: String
+  def list
+    statuses = Riffer::Rig::Settings.providers.to_h do |identifier|
+      [identifier, Riffer::Rig::Credentials.status(identifier)]
+    end
+    width = statuses.keys.map { |identifier| identifier.to_s.length }.max || 0
+    statuses.map { |identifier, status| "#{identifier.to_s.ljust(width)}  #{status}" }.join("\n")
+  end
+
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs identifier: String
+  # @rbs return: void
+  def rerun(ctx, identifier)
+    return ctx.say(hint) unless Riffer::Providers::Repository.find(identifier)
+
+    provider = identifier.to_sym
+    resolution = Riffer::Rig::Credentials.resolve(provider, host: ctx.host)
+    Riffer::Rig::Credentials.apply(provider, resolution.values)
+    ctx.runtime.merge_credentials(provider, resolution.values)
+    return ctx.host.notify(refusal(provider, resolution.missing), level: :error) unless resolution.missing.empty?
+
+    ctx.say("Updated #{provider} credentials")
+  end
+
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs identifier: String
+  # @rbs return: void
+  def remove(ctx, identifier)
+    return ctx.say(hint) unless Riffer::Providers::Repository.find(identifier)
+
+    Riffer::Rig::Credentials.remove(identifier)
+    ctx.say("Removed stored #{identifier} credentials")
+  end
+
+  # @rbs provider: Symbol
+  # @rbs missing: Array[Symbol]
+  # @rbs return: String
+  def refusal(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} still has no #{wanted}"
+  end
+end

data/lib/riffer/rig/commands/model.rb

@@ -3,16 +3,13 @@
 module Riffer::Rig::Commands::Model
   extend self
 
-  HINT = 'Use /model provider/name, with a provider from: ' \
-         "#{Riffer::Rig::Settings::PROVIDERS.join(', ')}".freeze #: String
-
-  SAVE_UNAVAILABLE = '/model --save is not available in this host'
+  SAVE = '--save' #: String
 
   # @rbs return: Riffer::Rig::Command
   def command
     Riffer::Rig::Command.new(
       'model',
-      description: 'Switch the model for this session: /model provider/name',
+      description: 'Switch the model for this session: /model provider/name, /model --save',
       extension: 'core'
     ) { |ctx| run(ctx) }
   end
@@ -20,35 +17,87 @@ module Riffer::Rig::Commands::Model
   # @rbs ctx: Riffer::Rig::Command::Context
   # @rbs return: void
   def run(ctx)
-    model = ctx.args.strip
-    return ctx.host.notify(SAVE_UNAVAILABLE, level: :error) if model.split.include?('--save')
-    return ctx.say("Model: #{ctx.runtime.model}") if model.empty?
+    words = ctx.args.split
+    save = words.delete(SAVE)
+    model = words.join(' ')
 
-    provider = Riffer::Rig::Settings.provider_for(model)
-    return ctx.say(HINT) unless provider && Riffer::Providers::Repository.find(provider)
+    if model.empty?
+      return ctx.say("Model: #{ctx.runtime.model}") unless save
+
+      Riffer::Rig::Settings.store_model(ctx.runtime.model)
+      return ctx.say("Saved #{ctx.runtime.model} to settings")
+    end
 
-    missing = missing_credentials(provider, ctx.runtime.credentials)
-    return ctx.host.notify(refusal(model, provider, missing), level: :error) unless missing.empty?
+    provider = Riffer::Rig::Settings.provider_for(model)
+    return ctx.say(hint) unless provider && Riffer::Providers::Repository.find(provider)
+    return unless ready?(ctx, model, provider)
 
     ctx.runtime.model = model
+    Riffer::Rig::Settings.store_model(model) if save
     ctx.say("Model: #{model}")
   end
 
   private
 
+  # @rbs return: String
+  def hint
+    "Use /model provider/name, with a provider from: #{Riffer::Rig::Settings.providers.join(', ')}"
+  end
+
+  # The same setup flows the Loader runs when it builds a Runtime: the
+  # provider's SDK gem, then its credentials, asked for when the host can ask.
+  # @rbs ctx: Riffer::Rig::Command::Context
   # @rbs model: String
   # @rbs provider: String
-  # @rbs missing: Array[Symbol]
-  # @rbs return: String
-  def refusal(model, provider, missing)
-    "Not switching to #{model}: #{provider} has no #{missing.join(', ')} in credentials"
+  # @rbs return: bool
+  def ready?(ctx, model, provider)
+    setup = Riffer::Rig::ProviderSetup[provider]
+    return true unless setup
+
+    sdk = setup.sdk
+    if sdk
+      message = Riffer::Rig::SDK.ensure(sdk[0], sdk[1], host: ctx.host)
+      if message
+        ctx.host.notify(message, level: :error)
+        return false
+      end
+    end
+
+    credentials_ready?(ctx, model, provider, setup)
   end
 
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs model: String
   # @rbs provider: String
-  # @rbs credentials: Hash[Symbol, Hash[Symbol, String]]
-  # @rbs return: Array[Symbol]
-  def missing_credentials(provider, credentials)
-    required = Riffer::Rig::ProviderSetup[provider]&.fields&.select(&:required) || []
-    required.map(&:name).reject { |name| credentials.dig(provider.to_sym, name) }
+  # @rbs setup: Riffer::Rig::ProviderSetup
+  # @rbs return: bool
+  def credentials_ready?(ctx, model, provider, setup)
+    missing = setup.fields.select(&:required)
+                   .map(&:name)
+                   .reject { |name| ctx.runtime.credentials.dig(provider.to_sym, name) }
+    return true if missing.empty?
+
+    resolution = Riffer::Rig::Credentials.resolve(provider, host: ctx.host)
+    unfilled = missing & resolution.missing
+    if unfilled.empty?
+      Riffer::Rig::Credentials.apply(provider, resolution.values)
+      empty = {} #: Hash[Symbol, String]
+      values = ctx.runtime.credentials.fetch(provider.to_sym, empty).merge(resolution.values)
+      ctx.runtime.merge_credentials(provider.to_sym, values)
+      true
+    else
+      refuse(ctx, model, provider, unfilled)
+      false
+    end
+  end
+
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs model: String
+  # @rbs provider: String
+  # @rbs missing: Array[Symbol]
+  # @rbs return: void
+  def refuse(ctx, model, provider, missing)
+    wanted = Riffer::Rig::ProviderSetup.for(provider).missing_fields(missing)
+    ctx.host.notify("Not switching to #{model}: #{provider} has no #{wanted}", level: :error)
   end
 end

data/lib/riffer/rig/commands/reload.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Riffer::Rig::Commands::Reload
+  extend self
+
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs return: Riffer::Rig::Command
+  def command(loader)
+    Riffer::Rig::Command.new(
+      'reload',
+      description: 'Reload the rig.rb files, settings, credentials and trust',
+      extension: 'core'
+    ) { |ctx| run(loader, ctx) }
+  end
+
+  # @rbs loader: Riffer::Rig::Loader
+  # @rbs ctx: Riffer::Rig::Command::Context
+  # @rbs return: void
+  def run(loader, ctx)
+    reloaded = loader.reload(ctx.runtime, force: true)
+    ctx.say('Reloaded') if reloaded.is_a?(Riffer::Rig::Runtime)
+  end
+end

data/lib/riffer/rig/credentials.rb

@@ -11,6 +11,9 @@ module Riffer::Rig::Credentials
 
   ENTRY_TYPE = 'api_key'
 
+  # @rbs @applied: Hash[Symbol, Hash[Symbol, String]]
+  @applied = {} #: Hash[Symbol, Hash[Symbol, String]]
+
   # @rbs identifier: String | Symbol
   # @rbs host: Riffer::Rig::Hosts::_Host
   # @rbs setup: Riffer::Rig::ProviderSetup
@@ -39,17 +42,26 @@ module Riffer::Rig::Credentials
     Resolution.new(values:, missing: required.map(&:name) - values.keys)
   end
 
+  # A registered extension provider has no Riffer::Config member, so the
+  # assignment stays built-ins-only.
   # @rbs identifier: String | Symbol
   # @rbs values: Hash[Symbol, String]
   # @rbs config: Riffer::Config
   # @rbs return: void
   def apply(identifier, values, config: Riffer.config)
-    return unless Riffer::Rig::ProviderSetup[identifier]
+    @applied[identifier.to_sym] = values.dup.freeze
+    return unless Riffer::Rig::ProviderSetup::TABLE.key?(identifier.to_sym)
 
     provider_config = config.public_send(identifier)
     values.each { |name, value| provider_config.public_send(:"#{name}=", value) }
   end
 
+  # @rbs identifier: String | Symbol
+  # @rbs return: Hash[Symbol, String]?
+  def read(identifier)
+    @applied[identifier.to_sym]
+  end
+
   # @rbs identifier: String | Symbol
   # @rbs values: Hash[Symbol, String]
   # @rbs setup: Riffer::Rig::ProviderSetup

data/lib/riffer/rig/extension.rb

@@ -30,6 +30,18 @@ class Riffer::Rig::Extension
     @block.call(registrar)
   end
 
+  # @rbs registrar: Riffer::Rig::Registrar
+  # @rbs return: StandardError?
+  def load_into(registrar)
+    rejection = mismatch || registrar.collision
+    return rejection if rejection
+
+    run(registrar)
+    nil
+  rescue StandardError => e
+    e
+  end
+
   private
 
   # @rbs requirement: Gem::Requirement?