riffer-rig 0.5.0 → 0.6.0

data/lib/riffer/rig/events/skill_activated.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::SkillActivated < Riffer::Rig::Events::Event
+  # @dynamic name
+  attr_reader :name #: String
+
+  # @rbs name: String
+  # @rbs return: void
+  def initialize(name)
+    super()
+    @name = name
+    freeze
+  end
+
+  # @rbs return: Symbol
+  def type
+    :skill_activated
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, name: name }
+  end
+end

data/lib/riffer/rig/events/turn_end.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Events::TurnEnd < Riffer::Rig::Events::Event
+  # @dynamic stop_reason, usage
+  attr_reader :stop_reason #: Symbol
+  attr_reader :usage #: ::Riffer::Providers::TokenUsage?
+
+  # @rbs stop_reason: Symbol
+  # @rbs usage: ::Riffer::Providers::TokenUsage?
+  # @rbs return: void
+  def initialize(stop_reason, usage)
+    super()
+    @stop_reason = stop_reason
+    @usage = usage
+    freeze
+  end
+
+  # @rbs return: Float?
+  def cost
+    usage&.cost
+  end
+
+  # @rbs return: Symbol
+  def type
+    :turn_end
+  end
+
+  # @rbs return: Hash[Symbol, untyped]
+  def to_h
+    { type: type, stop_reason: stop_reason, usage: usage }
+  end
+end

data/lib/riffer/rig/events.rb

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

data/lib/riffer/rig/extension.rb

@@ -1,9 +1,5 @@
 # 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?

data/lib/riffer/rig/hosts/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Hosts::Base
+  # @rbs return: Set[Symbol]
+  def capabilities
+    raise NotImplementedError, "#{self.class} must implement #{__method__}"
+  end
+
+  # @rbs question: String?
+  # @rbs options: Array[String]?
+  # @rbs secret: bool
+  # @rbs return: String?
+  def ask(question = nil, options: nil, secret: false)
+    raise NotImplementedError, "#{self.class} must implement #{__method__}"
+  end
+
+  # @rbs question: String?
+  # @rbs return: bool
+  def confirm(question = nil)
+    raise NotImplementedError, "#{self.class} must implement #{__method__}"
+  end
+
+  # @rbs message: String?
+  # @rbs level: Symbol
+  # @rbs return: void
+  def notify(message = nil, level: :info)
+    raise NotImplementedError, "#{self.class} must implement #{__method__}"
+  end
+
+  # @rbs label: String?
+  # @rbs &: ? () -> void
+  # @rbs return: void
+  def progress(label = nil, &)
+    raise NotImplementedError, "#{self.class} must implement #{__method__}"
+  end
+end

data/lib/riffer/rig/hosts/mirror.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Hosts::Mirror < Riffer::Rig::Hosts::Base
+  # @rbs @host: Riffer::Rig::Hosts::Base
+  # @rbs @queue: Array[Riffer::Rig::Events::Event]
+
+  # @dynamic capabilities
+  attr_reader :capabilities #: Set[Symbol]
+
+  # @rbs host: Riffer::Rig::Hosts::Base
+  # @rbs return: void
+  def initialize(host)
+    super()
+    @host = host
+    @capabilities = host.capabilities
+    @queue = []
+  end
+
+  # @rbs question: String?
+  # @rbs options: Array[String]?
+  # @rbs secret: bool
+  # @rbs return: String?
+  def ask(question = nil, options: nil, secret: false)
+    @host.ask(question, options: options, secret: secret)
+  end
+
+  # @rbs question: String?
+  # @rbs return: bool
+  def confirm(question = nil)
+    @host.confirm(question)
+  end
+
+  # @rbs message: String?
+  # @rbs level: Symbol
+  # @rbs return: void
+  def notify(message = nil, level: :info)
+    queue(Riffer::Rig::Events::Notify.new(message, level))
+    @host.notify(message, level: level)
+  end
+
+  # @rbs label: String?
+  # @rbs &block: ? () -> void
+  # @rbs return: void
+  def progress(label = nil, &block)
+    @host.progress(label) { block&.call }
+  end
+
+  # @rbs event: Riffer::Rig::Events::Event
+  # @rbs return: void
+  def queue(event)
+    @queue << event
+  end
+
+  # @rbs return: Array[Riffer::Rig::Events::Event]
+  def drain
+    queued = @queue
+    @queue = []
+    queued
+  end
+end

data/lib/riffer/rig/hosts/null.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Hosts::Null < Riffer::Rig::Hosts::Base
+  # @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/provider_setup/field.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::ProviderSetup::Field
+  # @dynamic name, env, secret, required, fallback
+  attr_reader :name #: Symbol
+  attr_reader :env #: Array[String]
+  attr_reader :secret, :required #: bool
+  attr_reader :fallback #: (^() -> String?)?
+
+  # @rbs name: Symbol
+  # @rbs env: Array[String]
+  # @rbs secret: bool
+  # @rbs required: bool
+  # @rbs fallback: (^() -> String?)?
+  # @rbs return: void
+  def initialize(name:, env:, secret:, required:, fallback: nil)
+    @name = name
+    @env = env.freeze
+    @secret = secret
+    @required = required
+    @fallback = fallback
+    freeze
+  end
+end

data/lib/riffer/rig/provider_setup.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::ProviderSetup
+  # @dynamic url, chain, fields
+  attr_reader :url #: String?
+  attr_reader :chain #: bool
+  attr_reader :fields #: Array[Riffer::Rig::ProviderSetup::Field]
+
+  # @rbs fields: Array[Riffer::Rig::ProviderSetup::Field]
+  # @rbs url: String?
+  # @rbs chain: bool
+  # @rbs return: void
+  def initialize(fields:, url: nil, chain: false)
+    @url = url
+    @chain = chain
+    @fields = fields.freeze
+    freeze
+  end
+
+  AWS_SHARED_CONFIG_REGION = lambda do
+    require 'aws-sdk-core'
+    Object.const_get(:Aws).shared_config.region
+  rescue LoadError
+    nil
+  end #: ^() -> String?
+
+  # Upstream candidate: each riffer provider could declare its own credential
+  # fields, and this table would go.
+  TABLE = {
+    anthropic: new(
+      url: 'https://console.anthropic.com/settings/keys',
+      fields: [Field.new(name: :api_key, env: ['ANTHROPIC_API_KEY'], secret: true, required: true)]
+    ),
+    openai: new(
+      url: 'https://platform.openai.com/api-keys',
+      fields: [
+        Field.new(name: :api_key, env: ['OPENAI_API_KEY'], secret: true, required: true),
+        Field.new(name: :base_url, env: ['OPENAI_BASE_URL'], secret: false, required: false)
+      ]
+    ),
+    gemini: new(
+      url: 'https://aistudio.google.com/app/apikey',
+      fields: [Field.new(name: :api_key, env: ['GEMINI_API_KEY'], secret: true, required: true)]
+    ),
+    openrouter: new(
+      url: 'https://openrouter.ai/keys',
+      fields: [Field.new(name: :api_key, env: ['OPENROUTER_API_KEY'], secret: true, required: true)]
+    ),
+    azure_openai: new(
+      url: 'https://portal.azure.com',
+      fields: [
+        Field.new(name: :endpoint, env: ['AZURE_OPENAI_ENDPOINT'], secret: false, required: true),
+        Field.new(name: :api_key, env: ['AZURE_OPENAI_API_KEY'], secret: true, required: true)
+      ]
+    ),
+    amazon_bedrock: new(
+      url: 'https://console.aws.amazon.com/bedrock',
+      chain: true,
+      fields: [
+        Field.new(
+          name: :region,
+          env: %w[AWS_REGION AWS_DEFAULT_REGION],
+          secret: false,
+          required: true,
+          fallback: AWS_SHARED_CONFIG_REGION
+        ),
+        Field.new(name: :api_token, env: ['AWS_BEARER_TOKEN_BEDROCK'], secret: true, required: false)
+      ]
+    )
+  }.freeze #: Hash[Symbol, Riffer::Rig::ProviderSetup]
+
+  # @rbs identifier: String | Symbol
+  # @rbs return: Riffer::Rig::ProviderSetup?
+  def self.[](identifier)
+    TABLE[identifier.to_sym]
+  end
+
+  # @rbs identifier: String | Symbol
+  # @rbs return: Riffer::Rig::ProviderSetup
+  def self.for(identifier)
+    self[identifier] ||
+      new(fields: [Field.new(name: :api_key, env: ["#{identifier.to_s.upcase}_API_KEY"], secret: true, required: true)])
+  end
+end

data/lib/riffer/rig/registrar.rb

@@ -1,13 +1,13 @@
 # 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 @prompts: Hash[Symbol, ^(Riffer::Rig::Runtime) -> String?]
 
   # @rbs return: void
   def initialize
     @tools = []
+    @prompts = {}
   end
 
   # @rbs klass: singleton(Riffer::Tool)
@@ -16,8 +16,20 @@ class Riffer::Rig::Registrar
     @tools << klass
   end
 
+  # @rbs name: Symbol
+  # @rbs &block: (Riffer::Rig::Runtime) -> String?
+  # @rbs return: void
+  def prompt(name, &block)
+    @prompts[name] = block
+  end
+
   # @rbs return: Array[singleton(Riffer::Tool)]
   def tools
     @tools.dup
   end
+
+  # @rbs return: Hash[Symbol, ^(Riffer::Rig::Runtime) -> String?]
+  def prompts
+    @prompts.dup
+  end
 end

data/lib/riffer/rig/repl.rb

@@ -73,6 +73,8 @@ class Riffer::Rig::REPL
   # @rbs prompt: String
   # @rbs return: void
   def run_turn(prompt)
+    # A hidden cursor can't flicker against the animator's erase-and-redraw
+    # churn.
     @cursor.hide
     start_animator
     @smoother.start
@@ -154,13 +156,11 @@ class Riffer::Rig::REPL
     "<skill name=\"#{name}\">\n#{body}\n</skill>"
   end
 
-  # Chrome lines that never pass through the renderer (errors, exit line) end
-  # 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(&)
+    # Bypasses the renderer's tool-group state: these lines (errors, the exit
+    # line) can only follow prose, never land mid-group.
     @output.puts
     @output.puts(yield)
     @output.flush
@@ -176,13 +176,12 @@ class Riffer::Rig::REPL
     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)
+    # 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.
     @smoother.drain
     @animator.start(mode)
   end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Riffer::Rig::Runtime::CancelFlag
+  # @rbs @mutex: Thread::Mutex
+  # @rbs @set: bool
+
+  # @rbs return: void
+  def initialize
+    @mutex = Mutex.new
+    @set = false
+  end
+
+  # @rbs return: void
+  def set
+    @mutex.synchronize { @set = true }
+  end
+
+  # @rbs return: void
+  def clear
+    @mutex.synchronize { @set = false }
+  end
+
+  # @rbs return: bool
+  def set?
+    @mutex.synchronize { @set }
+  end
+end

data/lib/riffer/rig/runtime.rb

@@ -1,25 +1,15 @@
 # frozen_string_literal: true
 
 require 'date'
+require 'securerandom'
 
-# 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.
+# Never renders, prints or reads the filesystem: anything a host needs is a
+# Runtime feature, so embedders get it too.
 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
 
+  class ClosedError < 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.
@@ -33,41 +23,42 @@ class Riffer::Rig::Runtime
 
   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.
+  # Unlimited: 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
+  INTERRUPT_CANCELLED = :cancelled #: Symbol
 
   # @rbs @agent: Riffer::Agent
+  # @rbs @base_prompt: String
+  # @rbs @cancel_flag: Riffer::Rig::Runtime::CancelFlag
+  # @rbs @credentials: Hash[Symbol, Hash[Symbol, String]]
   # @rbs @cwd: String
-  # @rbs @host: _Host
+  # @rbs @host: Riffer::Rig::Hosts::Mirror
+  # @rbs @id: String
   # @rbs @settings: Hash[Symbol, untyped]
   # @rbs @busy: bool
+  # @rbs @closed: bool
+  # @rbs @session_start_pending: bool
   # @rbs @registrar: Riffer::Rig::Registrar
 
-  # @dynamic agent, cwd, host, settings
+  # @dynamic agent, credentials, cwd, host, id, settings
   attr_reader :agent #: Riffer::Agent
+  attr_reader :credentials #: Hash[Symbol, Hash[Symbol, String]]
   attr_reader :cwd #: String
-  attr_reader :host #: _Host
+  attr_reader :host #: Riffer::Rig::Hosts::Mirror
+  attr_reader :id #: String
   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 host: Riffer::Rig::Hosts::Base
   # @rbs cwd: String?
   # @rbs name: String
   # @rbs instructions: String?
-  # @rbs credentials: Hash[String, String]
+  # @rbs credentials: Hash[Symbol, Hash[Symbol, String]]
   # @rbs pricing: Hash[String, Riffer::Rig::Settings::Pricing]
   # @rbs max_steps: Integer?
   # @rbs snapshot: Hash[Symbol, untyped]?
@@ -77,7 +68,7 @@ class Riffer::Rig::Runtime
     extensions: [],
     tools: nil,
     settings: {},
-    host: Riffer::Rig::Host.new,
+    host: Riffer::Rig::Hosts::Null.new,
     cwd: nil,
     name: DEFAULT_NAME,
     instructions: nil,
@@ -86,37 +77,48 @@ class Riffer::Rig::Runtime
     max_steps: DEFAULT_MAX_STEPS,
     snapshot: nil
   )
-    @host = host
+    # Doubles as the snapshot id and ACP sessionId.
+    @id = ::SecureRandom.uuid_v7
+    @host = Riffer::Rig::Hosts::Mirror.new(host)
     @cwd = cwd || Dir.pwd
     @settings = settings
+    @credentials = credentials
 
     @busy = false
+    @closed = false
+    @cancel_flag = Riffer::Rig::Runtime::CancelFlag.new
+    @session_start_pending = true
     @registrar = build_registrar(extensions)
     tool_classes = select_tools(@registrar.tools, tools)
-    base_prompt = instructions || format(BASE_PROMPT_TEMPLATE, name: name)
+    @base_prompt = instructions || format(BASE_PROMPT_TEMPLATE, name: name)
 
     @agent = Riffer::Agent.new(
+      context: { cancel_flag: @cancel_flag },
       config: Riffer::Agent::Config.new(
         model: model,
-        instructions: system_prompt(base_prompt),
+        instructions: system_prompt([]),
         tools_config: tool_classes,
         max_steps: max_steps
       )
     )
+    @agent.session.on_message { |_message| interrupt_if_cancelled }
   end
 
   # @rbs text: String
-  # @rbs &block: ?(Riffer::StreamEvents::Base) -> void
-  # @rbs return: (nil | Enumerator[Riffer::StreamEvents::Base, void])
+  # @rbs &block: ?(::Riffer::StreamEvents::Base | Riffer::Rig::Events::Event) -> void
+  # @rbs return: (nil | Enumerator[::Riffer::StreamEvents::Base | Riffer::Rig::Events::Event, Riffer::Agent::Response])
   def prompt(text, &block)
     raise BusyError, 'a prompt is already running on this Runtime' if @busy
+    raise ClosedError, 'this Runtime is closed' if @closed
 
     @busy = true
+    @cancel_flag.clear
+    refresh_system_message
     if block
-      @agent.stream(text).each(&block)
+      wrap_stream(@agent.stream(text)).each(&block)
       nil
     else
-      @agent.stream(text)
+      wrap_stream(@agent.stream(text))
     end
   ensure
     @busy = false
@@ -126,15 +128,63 @@ class Riffer::Rig::Runtime
   # @rbs return: Riffer::Agent::Response
   def ask(text)
     raise BusyError, 'a prompt is already running on this Runtime' if @busy
+    raise ClosedError, 'this Runtime is closed' if @closed
 
     @busy = true
+    @cancel_flag.clear
+    refresh_system_message
     @agent.stream(text).each { |event| event }
   ensure
     @busy = false
   end
 
+  # @rbs return: nil
+  def cancel
+    @cancel_flag.set
+    nil
+  end
+
+  # @rbs return: void
+  def close
+    # TODO: emit Riffer::Rig::Events::SessionEnd once the rebuild ticket settles
+    # the stream's session_end reasons.
+    @closed = true
+  end
+
   private
 
+  # @rbs stream: Enumerator[Riffer::StreamEvents::Base, Riffer::Agent::Response]
+  # @rbs return: Enumerator[::Riffer::StreamEvents::Base | Riffer::Rig::Events::Event, Riffer::Agent::Response]
+  def wrap_stream(stream)
+    Enumerator.new do |yielder|
+      yielder << Riffer::Rig::Events::SessionStart.new(@id, :new) if @session_start_pending
+      @session_start_pending = false
+      @host.drain.each { |event| yielder << event }
+      response = stream.each { |event| yielder << event }
+      yielder << Riffer::Rig::Events::TurnEnd.new(stop_reason(response.outcome), response.token_usage)
+      response
+    end
+  end
+
+  # @rbs return: void
+  def interrupt_if_cancelled
+    return unless @cancel_flag.set?
+
+    @agent.session.discard_pending_tool_calls
+    # Upstream candidate: a cancel token on riffer's run loop. Until then the
+    # loop can only be stopped from inside, at a message boundary.
+    @agent.interrupt!(INTERRUPT_CANCELLED)
+  end
+
+  # @rbs outcome: Riffer::Agent::Outcome
+  # @rbs return: Symbol
+  def stop_reason(outcome)
+    # Upstream candidate: riffer's outcome vocabulary is closed, so a cancel
+    # reaches us as :interrupted with the reason in detail.
+    cancelled = outcome.reason == :interrupted && outcome.detail == INTERRUPT_CANCELLED.to_s
+    cancelled ? INTERRUPT_CANCELLED : outcome.reason
+  end
+
   # @rbs extensions: Array[Riffer::Rig::Extension]
   # @rbs return: Riffer::Rig::Registrar
   def build_registrar(extensions)
@@ -154,9 +204,22 @@ class Riffer::Rig::Runtime
     registered.select { |klass| allowlist.include?(klass.name) }
   end
 
-  # @rbs base_prompt: String
+  # @rbs return: void
+  def refresh_system_message
+    # Upstream candidate: riffer resolves `instructions` once, in Agent.new, so
+    # a per-turn system message has to be swapped into the session by hand.
+    session = @agent.session
+    session.set([Riffer::Messages::System.new(system_prompt(rendered_sections)), *session.messages.drop(1)])
+  end
+
+  # @rbs return: Array[String]
+  def rendered_sections
+    @registrar.prompts.each_value.map { |section| section.call(self).to_s }.reject(&:empty?)
+  end
+
+  # @rbs sections: Array[String]
   # @rbs return: String
-  def system_prompt(base_prompt)
-    "#{base_prompt}\n\nCurrent date: #{Date.today}\nCurrent working directory: #{@cwd}"
+  def system_prompt(sections)
+    [@base_prompt, *sections, "Current date: #{Date.today}\nCurrent working directory: #{@cwd}"].join("\n\n")
   end
 end

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

@@ -4,11 +4,13 @@ class Riffer::Rig::Settings::Document
   # @rbs @model: String?
   # @rbs @reasoning: String?
   # @rbs @models: Hash[String, Riffer::Rig::Settings::Pricing]
+  # @rbs @providers: Hash[String, Hash[String, String]]
 
-  # @dynamic model, reasoning, models
+  # @dynamic model, reasoning, models, providers
   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]]
 
   # @rbs source: untyped
   # @rbs return: void
@@ -19,5 +21,8 @@ class Riffer::Rig::Settings::Document
     @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
+    blocks = source['providers'].is_a?(Hash) ? source['providers'] : {} #: Hash[String, untyped]
+    @providers = blocks.select { |_identifier, fields| fields.is_a?(Hash) }
+                       .transform_values { |fields| fields.select { |_name, value| value.is_a?(String) } }
   end
 end