riffer 0.48.0 → 0.49.0

data/lib/riffer/evals/scenario_result.rb

@@ -1,24 +1,12 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Represents the result of evaluating a single scenario.
 class Riffer::Evals::ScenarioResult
-  # The input that was evaluated.
   attr_reader :input #: String # @dynamic input
-
-  # The agent output for this scenario.
   attr_reader :output #: String # @dynamic output
-
-  # The ground truth used during evaluation.
   attr_reader :ground_truth #: String? # @dynamic ground_truth
-
-  # Individual evaluation results.
   attr_reader :results #: Array[Riffer::Evals::Result] # @dynamic results
-
-  # The full message history from the agent conversation.
   attr_reader :messages #: Array[Riffer::Messages::Base] # @dynamic messages
-
-  # Token usage the agent under test spent generating this scenario's output.
   attr_reader :token_usage #: Riffer::Providers::TokenUsage? # @dynamic token_usage
 
   #--
@@ -32,8 +20,6 @@ class Riffer::Evals::ScenarioResult
     @token_usage = token_usage
   end
 
-  # Returns scores keyed by evaluator class.
-  #
   #--
   #: () -> Hash[singleton(Riffer::Evals::Evaluator), Float]
   def scores
@@ -43,17 +29,12 @@ class Riffer::Evals::ScenarioResult
     end
   end
 
-  # Returns the summed token usage across this scenario's LLM-as-judge
-  # evaluators, or nil when none reported usage.
-  #
   #--
   #: () -> Riffer::Providers::TokenUsage?
   def evaluator_token_usage
     results.filter_map(&:token_usage).reduce(:+)
   end
 
-  # Returns a hash representation of the scenario result.
-  #
   #--
   #: () -> Hash[Symbol, untyped]
   def to_h

data/lib/riffer/files/downloader.rb

@@ -33,9 +33,8 @@ class Riffer::Files::Downloader
     http.open_timeout = timeout
     http.read_timeout = timeout
 
-    # request_get without a block reads (and discards our chance to cap) the
-    # whole body before returning; the cap/read has to happen inside the
-    # block it yields to, where the body hasn't been consumed yet.
+    # request_get without a block reads the whole body before returning, so the
+    # size cap has to run inside the block, before the body is consumed.
     redirect_location = nil #: String?
     content = nil #: String?
 

data/lib/riffer/files/resolver.rb

@@ -14,10 +14,6 @@ class Riffer::Files::Resolver
     @config = Riffer.config.files
   end
 
-  # Resolves every file in every User message in place - downloading,
-  # verifying, and caching as the provider's capability and each file's
-  # sha256 require.  Raises Riffer::FileError on any file that can't be
-  # resolved
   #: (Array[Riffer::Messages::Base]) -> void
   def resolve!(messages)
     files = messages.flat_map do |message|
@@ -51,6 +47,8 @@ class Riffer::Files::Resolver
 
     case delivery
     when :url
+      # The request still sends the URL, never these bytes, so caching them
+      # would hold memory nothing reads and let later turns skip re-verifying.
       download!(file, cache: false) if file.sha256
     when :base64
       file.data ? verify_inline!(file) : download!(file, cache: :base64)
@@ -69,9 +67,6 @@ class Riffer::Files::Resolver
     verify_bytes!(file.data_bytes, file.sha256)
   end
 
-  # +cache:+ is false for a :url-delivery provider verifying a sha256 — the
-  # request still sends the URL, never the downloaded bytes, so caching them
-  # would hold memory nothing reads and let later turns skip re-verifying.
   #: (Riffer::Messages::User::FilePart, cache: (false | Symbol)) -> void
   def download!(file, cache:)
     raise Riffer::FileDownloadsDisabledError, "File attachments are disabled" unless @config.allow_downloads

data/lib/riffer/guardrail.rb

@@ -1,38 +1,21 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Base class for guardrails that process input and output in the agent pipeline.
-#
-#   class MyGuardrail < Riffer::Guardrail
-#     def process_input(messages, context:)
-#       # Return pass(messages), transform(modified_messages), or block(reason)
-#       pass(messages)
-#     end
-#
-#     def process_output(response, messages:, context:)
-#       # Return pass(response), transform(modified_response), or block(reason)
-#       pass(response)
-#     end
-#   end
 class Riffer::Guardrail
-  # Processes input messages before they're sent to the LLM; override in
-  # subclasses.
   #--
   #: (Array[Riffer::Messages::Base], context: untyped) -> Riffer::Guardrails::Result
   def process_input(messages, context:)
     pass(messages)
   end
 
-  # Processes the output response after it's received from the LLM; override in
-  # subclasses.
   #--
   #: (Riffer::Messages::Assistant, messages: Array[Riffer::Messages::Base], context: untyped) -> Riffer::Guardrails::Result
   def process_output(response, messages:, context:)
     pass(response)
   end
 
-  # Returns the guardrail's identifier, used as the tracing span suffix and the
-  # <tt>riffer.guardrail.name</tt> attribute; override to label the span.
+  # Used as the tracing span suffix and the <tt>riffer.guardrail.name</tt>
+  # attribute.
   #--
   #: () -> String
   def name
@@ -41,21 +24,18 @@ class Riffer::Guardrail
 
   protected
 
-  # Creates a pass result that continues with unchanged data.
   #--
   #: (untyped) -> Riffer::Guardrails::Result
   def pass(data)
     Riffer::Guardrails::Result.pass(data)
   end
 
-  # Creates a transform result that continues with transformed data.
   #--
   #: (untyped) -> Riffer::Guardrails::Result
   def transform(data)
     Riffer::Guardrails::Result.transform(data)
   end
 
-  # Creates a block result that halts execution.
   #--
   #: (String, ?metadata: Hash[Symbol, untyped]?) -> Riffer::Guardrails::Result
   def block(reason, metadata: nil)

data/lib/riffer/guardrails/modification.rb

@@ -1,15 +1,9 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Records a guardrail transformation event.
 class Riffer::Guardrails::Modification
-  # The guardrail class that transformed data.
   attr_reader :guardrail #: singleton(Riffer::Guardrail) # @dynamic guardrail
-
-  # The phase when the transformation occurred (:before or :after).
   attr_reader :phase #: Symbol # @dynamic phase
-
-  # The indices of messages that were changed.
   attr_reader :message_indices #: Array[Integer] # @dynamic message_indices
 
   #--
@@ -20,8 +14,6 @@ class Riffer::Guardrails::Modification
     @message_indices = message_indices
   end
 
-  # Converts the modification to a hash.
-  #
   #--
   #: () -> Hash[Symbol, untyped]
   def to_h

data/lib/riffer/guardrails/result.rb

@@ -1,36 +1,26 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Represents the result of a guardrail execution: +pass+ (continue unchanged),
-# +transform+ (continue with changed data), or +block+ (halt with a reason).
 class Riffer::Guardrails::Result
   TYPES = %i[pass transform block].freeze #: Array[Symbol]
 
-  # The result type (:pass, :transform, or :block).
   attr_reader :type #: Symbol # @dynamic type
-
-  # The data (for pass/transform) or reason (for block).
   attr_reader :data #: untyped # @dynamic data
-
-  # Optional metadata for block results.
   attr_reader :metadata #: Hash[Symbol, untyped]? # @dynamic metadata
 
   class << self
-    # Creates a pass result that continues with unchanged data.
     #--
     #: (untyped) -> Riffer::Guardrails::Result
     def pass(data)
       new(:pass, data)
     end
 
-    # Creates a transform result that continues with transformed data.
     #--
     #: (untyped) -> Riffer::Guardrails::Result
     def transform(data)
       new(:transform, data)
     end
 
-    # Creates a block result that halts execution.
     #--
     #: (String, ?metadata: Hash[Symbol, untyped]?) -> Riffer::Guardrails::Result
     def block(reason, metadata: nil)
@@ -38,7 +28,6 @@ class Riffer::Guardrails::Result
     end
   end
 
-  # Raises Riffer::ArgumentError if +type+ is not :pass, :transform, or :block.
   #--
   #: (Symbol, untyped, ?metadata: Hash[Symbol, untyped]?) -> void
   def initialize(type, data, metadata: nil)
@@ -49,24 +38,18 @@ class Riffer::Guardrails::Result
     @metadata = metadata
   end
 
-  # Returns true if this is a pass result.
-  #
   #--
   #: () -> bool
   def pass?
     type == :pass
   end
 
-  # Returns true if this is a transform result.
-  #
   #--
   #: () -> bool
   def transform?
     type == :transform
   end
 
-  # Returns true if this is a block result.
-  #
   #--
   #: () -> bool
   def block?

data/lib/riffer/guardrails/runner.rb

@@ -1,19 +1,13 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Executes guardrails sequentially, passing each one's output to the next; if
-# any blocks, execution stops and a tripwire is returned.
 class Riffer::Guardrails::Runner
-  # The guardrail configs to execute.
   attr_reader :guardrail_configs #: Array[Hash[Symbol, untyped]] # @dynamic guardrail_configs
 
-  # The execution phase (:before or :after).
   attr_reader :phase #: Symbol # @dynamic phase
 
-  # The context passed to guardrails.
   attr_reader :context #: untyped # @dynamic context
 
-  # The normalized per-call tags, stamped as +riffer.tag.*+ on guardrail spans.
   attr_reader :tags #: Hash[String, String] # @dynamic tags
 
   #--
@@ -25,9 +19,6 @@ class Riffer::Guardrails::Runner
     @tags = tags
   end
 
-  # Runs the guardrails sequentially. For the +:before+ phase +data+ is the
-  # messages array; for +:after+ it's the response (and +messages+ must be
-  # provided).
   #--
   #: (untyped, ?messages: Array[Riffer::Messages::Base]?) -> [untyped, Riffer::Guardrails::Tripwire?, Array[Riffer::Guardrails::Modification]]
   def run(data, messages: nil)
@@ -124,12 +115,12 @@ class Riffer::Guardrails::Runner
     }.merge(tags.transform_keys { |key| "riffer.tag.#{key}" })
   end
 
-  # A block is a handled outcome, so its span status stays unset — an error
-  # span status is reserved for a raised exception.
   #--
   #: ((Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span), Riffer::Guardrails::Result) -> void
   def record_guardrail_outcome(span, result)
     span.set_attribute("riffer.guardrail.action", result.type.to_s)
+    # A block is a handled outcome, so span status stays unset — error status
+    # is reserved for a raised exception.
     span.set_attribute("riffer.tripwire.reason", result.data) if result.block?
   end
 end

data/lib/riffer/guardrails/tripwire.rb

@@ -1,23 +1,17 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Captures information about a blocked guardrail execution.
 class Riffer::Guardrails::Tripwire
   PHASES = Riffer::Guardrails::PHASES #: Array[Symbol]
 
-  # The reason for blocking.
   attr_reader :reason #: String # @dynamic reason
 
-  # The guardrail class that triggered the block.
   attr_reader :guardrail #: singleton(Riffer::Guardrail) # @dynamic guardrail
 
-  # The phase when the block occurred (:before or :after).
   attr_reader :phase #: Symbol # @dynamic phase
 
-  # Optional metadata about the block.
   attr_reader :metadata #: Hash[Symbol, untyped]? # @dynamic metadata
 
-  # Raises Riffer::ArgumentError if +phase+ is invalid.
   #--
   #: (reason: String, guardrail: singleton(Riffer::Guardrail), phase: Symbol, ?metadata: Hash[Symbol, untyped]?) -> void
   def initialize(reason:, guardrail:, phase:, metadata: nil)
@@ -29,8 +23,6 @@ class Riffer::Guardrails::Tripwire
     @metadata = metadata
   end
 
-  # Converts the tripwire to a hash.
-  #
   #--
   #: () -> Hash[Symbol, untyped]
   def to_h

data/lib/riffer/guardrails.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Namespace for guardrail components that pre-process input and post-process
-# output in the agent pipeline.
 module Riffer::Guardrails
   PHASES = %i[before after].freeze #: Array[Symbol]
 end

data/lib/riffer/helpers/boolean.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Coercion for boolean-ish configuration values.
 module Riffer::Helpers::Boolean
   extend self
 
-  # Coerces +value+ to a boolean so an env-var +"false"+ (truthy in Ruby)
-  # doesn't silently read as +true+. Raises Riffer::ArgumentError on an
-  # unrecognized value, naming +attribute+ in the message.
   #--
   #: (untyped, attribute: String) -> bool
   def coerce(value, attribute:)

data/lib/riffer/helpers/call_or_value.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Resolves the Proc-or-value idiom.
 module Riffer::Helpers::CallOrValue
   extend self
 
-  # Calls +thing+ when it's a Proc (passing +context+ if its arity is non-zero),
-  # returns it unchanged otherwise, or +default+ when +nil+.
   #--
   #: (untyped, ?context: untyped, ?default: untyped) -> untyped
   def resolve(thing, context: nil, default: nil)

data/lib/riffer/helpers/deep_dup.rb

@@ -1,20 +1,14 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Copying for the nested Hashes and Arrays a configuration object holds.
 module Riffer::Helpers::DeepDup
   extend self
 
-  # Returns +value+ with every Hash and Array rebuilt, so a copy shares no
-  # collection with its source.
-  #
-  # Anything else is returned as-is, which a Class or a Proc needs: +Class#dup+
-  # answers a new anonymous class. One source collection maps to one copy, so
-  # references shared within +value+ stay shared in the result — an +:around+
-  # guardrail registered under two phases is still one registration afterwards.
   #--
   #: (untyped) -> untyped
   def call(value)
+    # References shared within +value+ stay shared in the copy — an +:around+
+    # guardrail registered under two phases is still one registration.
     seen = {} #: Hash[untyped, untyped]
 
     rebuild(value, seen.compare_by_identity)
@@ -36,6 +30,7 @@ module Riffer::Helpers::DeepDup
       copy = seen[value] = []
       value.each { |entry| copy << rebuild(entry, seen) }
       copy
+    # Class#dup answers a new anonymous class, so non-collections stay as-is.
     else value
     end
   end

data/lib/riffer/helpers/dependencies.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Lazy-loads gem dependencies — used by providers to load required gems only
-# when needed.
 module Riffer::Helpers::Dependencies
   extend self
 
-  # Raised when a required gem cannot be loaded.
   class LoadError < ::LoadError; end
 
-  # Requires a gem by name; raises LoadError if it isn't installed.
   #--
   #: (String) -> true
   def depends_on(gem_name)

data/lib/riffer/helpers/identifier.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Helper module for deriving snake_case identifiers from class names.
 module Riffer::Helpers::Identifier
   extend self
 
-  # Derives a snake_case identifier from a class name string.
-  #
   #--
   #: (String?) -> String
   def derive(class_name)
@@ -18,11 +15,6 @@ module Riffer::Helpers::Identifier
       downcase
   end
 
-  # Derives and memoizes the identifier for a class or module. Anonymous
-  # classes return "" without caching, so a class named later still derives its
-  # real identifier — a guard that must travel with the cache, so callers never
-  # memoize their own.
-  #
   #--
   #: (Module) -> String
   def for(klass)
@@ -30,6 +22,8 @@ module Riffer::Helpers::Identifier
     return cached if cached
 
     real_name = real_name(klass)
+    # Anonymous classes skip the cache so a class named later still derives its
+    # real identifier; callers must not memoize their own for the same reason.
     return "" if real_name.nil?
 
     derived = derive(real_name)
@@ -37,13 +31,10 @@ module Riffer::Helpers::Identifier
     derived
   end
 
-  # Returns the class-path name of a class or module, or +nil+ when anonymous.
-  # Tool classes shadow Module#name with the identifier DSL, so the real name
-  # must come from Module's own implementation.
-  #
   #--
   #: (Module) -> String?
   def real_name(klass)
+    # Tool classes shadow Module#name with the identifier DSL.
     Module.instance_method(:name).bind_call(klass) #: String?
   end
 end

data/lib/riffer/helpers/validate.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Riffer::Helpers::Validate
+  extend self
+
+  # The error names the class, not the value, so a misassigned secret never
+  # lands in a log.
+  #--
+  #: (untyped, attribute: String) -> String?
+  def optional_string(value, attribute:)
+    return value if value.nil? || value.is_a?(String)
+
+    raise Riffer::ArgumentError, "#{attribute} must be a String or nil, got #{value.class}"
+  end
+
+  #--
+  #: (untyped, attribute: String) -> Integer
+  def positive_integer(value, attribute:)
+    return value if value.is_a?(Integer) && value.positive?
+
+    raise Riffer::ArgumentError, "#{attribute} must be a positive integer"
+  end
+
+  #--
+  #: (untyped, attribute: String) -> Riffer::Runner
+  def runner(value, attribute:)
+    return value if value.is_a?(Riffer::Runner)
+
+    raise Riffer::ArgumentError, "#{attribute} must be a Riffer::Runner instance"
+  end
+
+  #--
+  #: (untyped, attribute: String) -> String
+  def model_id(value, attribute:)
+    segments = value.to_s.split("/", 2)
+    valid = value.is_a?(String) && segments.length == 2 && segments.none? { |segment| segment.strip.empty? }
+    return value if valid
+
+    raise Riffer::ArgumentError, "#{attribute} must be in \"provider/model\" form, got #{value.inspect}"
+  end
+end

data/lib/riffer/mcp/authenticated_tool.rb

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Wraps MCP-generated tool classes so +tools/call+ resolves
-# +Riffer.config.mcp.credentials+ per invocation, copying metadata from the
-# inner class at wrap time.
 module Riffer::Mcp::AuthenticatedTool
   extend self
 
-  # Returns one wrapper class per inner tool, sharing +manifest+ and +matched_tags+.
-  #
   #--
   #: (Array[singleton(Riffer::Mcp::Tool)], Riffer::Mcp::Manifest, Array[Symbol]) -> Array[singleton(Riffer::Mcp::Tool)]
   def wrap_all(tool_classes, manifest, matched_tags)
@@ -23,8 +18,7 @@ module Riffer::Mcp::AuthenticatedTool
     tags = matched_tags
 
     # steep does not model Class.new's class_eval semantics — the block body
-    # typechecks against the enclosing module, so the ivar assignments and the
-    # define_method bodies are unresolvable.
+    # typechecks against the enclosing module.
     Class.new(Riffer::Mcp::Tool) do
       # steep:ignore:start
       @identifier = inner.identifier
@@ -32,11 +26,9 @@ module Riffer::Mcp::AuthenticatedTool
       @input_schema = inner.parameters_schema
       @mcp_server_tool_name = inner.mcp_server_tool_name
 
-      # Creates a fresh client per +tools/call+ so headers from the credentials
-      # proc stay current.
-      # TODO: A per-headers cache would reduce connection churn under load, and
-      # requires a follow-up investigation to determine how to invalidate failing
-      # clients.
+      # A fresh client per +tools/call+ keeps credentials-proc headers current at
+      # the cost of connection churn; a per-headers cache would first need a way
+      # to invalidate failing clients.
       define_method(:build_call_client) do |endpoint, headers|
         Riffer::Mcp::Client.new(endpoint: endpoint, headers: headers)
       end

data/lib/riffer/mcp/client.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Thin wrapper around the MCP Ruby SDK client (mcp gem v0.8+). Resolves headers
-# (if a Proc) once at init, then provides +tools_list+ / +tools_call+ — used for
-# discovery and for +tools/call+ when no +credentials+ proc is configured.
 class Riffer::Mcp::Client
   # @rbs @client: untyped
 
@@ -20,8 +17,6 @@ class Riffer::Mcp::Client
     end
   end
 
-  # Returns tool definition hashes with +:name+, +:description+, and
-  # +:input_schema+ keys.
   #--
   #: () -> Array[Hash[Symbol, untyped]]
   def tools_list
@@ -34,8 +29,6 @@ class Riffer::Mcp::Client
     end
   end
 
-  # Calls a tool on the MCP server and returns joined text content from the response.
-  #
   #--
   #: (String, ?Hash[untyped, untyped]) -> String
   def tools_call(name, arguments = {})

data/lib/riffer/mcp/manifest.rb

@@ -3,22 +3,18 @@
 
 require "uri"
 
-# Holds the configuration for a single MCP server.
 class Riffer::Mcp::Manifest
-  # Identifier used as the registration key and generated-agent identifier.
   attr_reader :name #: String # @dynamic name
 
-  # Tags for matching +use_mcp+.
   attr_reader :tags #: Array[Symbol] # @dynamic tags
 
-  # HTTPS URL passed to the MCP transport.
   attr_reader :endpoint #: String # @dynamic endpoint
 
-  # Headers (or a Proc) resolved once when building the discovery client.
+  # Resolved once, when building the discovery client.
   attr_reader :discovery_headers #: (Hash[String, untyped] | ::Proc)? # @dynamic discovery_headers
 
-  # Optional hint (+:global+/+:tenant+/+:user+) for whether invocation
-  # credentials depend on tenant/user keys in +context+.
+  # +:global+, +:tenant+, or +:user+: whether invocation credentials depend on
+  # tenant/user keys in +context+.
   attr_reader :credentials_scope #: Symbol? # @dynamic credentials_scope
 
   # Raises Riffer::ArgumentError unless +name+ is present and +endpoint+ is a

data/lib/riffer/mcp/registration.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Per-server state managed by Riffer::Mcp::Registry — discovers tools via
-# +tools/list+ and generates tool classes when a server is registered.
 class Riffer::Mcp::Registration
   # @rbs @cancelled: bool
   # @rbs @tools: Array[singleton(Riffer::Mcp::Tool)]
   # @rbs @mutex: Thread::Mutex
 
-  # The manifest that describes this server.
   attr_reader :manifest #: Riffer::Mcp::Manifest # @dynamic manifest
 
-  # Generated Riffer::Mcp::Tool subclasses.
-  #
   #--
   #: () -> Array[singleton(Riffer::Mcp::Tool)]
   def tools
@@ -29,17 +24,12 @@ class Riffer::Mcp::Registration
     run_discovery
   end
 
-  # Retires this registration, preventing in-flight discovery from publishing
-  # state.
-  #
   #--
   #: () -> void
   def retire!
     @mutex.synchronize { @cancelled = true }
   end
 
-  # Returns true if this registration has been retired.
-  #
   #--
   #: () -> bool
   def retired?

data/lib/riffer/mcp/registry.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Thread-safe global store for MCP server registrations, keyed by manifest name.
 module Riffer::Mcp::Registry
   extend self
 
@@ -11,8 +10,6 @@ module Riffer::Mcp::Registry
   @mutex = Mutex.new
   @store = {} #: Hash[String, Riffer::Mcp::Registration]
 
-  # Registers an MCP server and starts async tool discovery, replacing any
-  # existing registration with the same name.
   #--
   #: ((Hash[Symbol, untyped] | Riffer::Mcp::Manifest)) -> Riffer::Mcp::Registration
   def register(manifest_or_hash)
@@ -33,8 +30,6 @@ module Riffer::Mcp::Registry
     registration
   end
 
-  # Removes a registration by name.
-  #
   #--
   #: ((String | Symbol)) -> void
   def unregister(name)
@@ -42,16 +37,12 @@ module Riffer::Mcp::Registry
     removed&.retire!
   end
 
-  # Returns a frozen snapshot of all current registrations.
-  #
   #--
   #: () -> Hash[String, Riffer::Mcp::Registration]
   def registrations
     @mutex.synchronize { @store.dup.freeze }
   end
 
-  # Returns all registrations whose manifest tags intersect the given tags
-  # (normalized to symbols).
   #--
   #: (Array[Symbol]) -> Array[Riffer::Mcp::Registration]
   def find_by_tags(tags)