riffer 0.30.0 → 0.32.0

data/sig/generated/riffer/evals/evaluator.rbs

@@ -1,12 +1,8 @@
 # Generated from lib/riffer/evals/evaluator.rb with RBS::Inline
 
-# Base class for all evaluators in the Riffer framework.
-#
-# Provides a DSL for defining evaluator metadata and the evaluate method.
-# Simple evaluators only need to set +instructions+ — the base class
-# handles calling the judge automatically.
-#
-# See examples/evaluators/ for reference implementations.
+# Base class for all evaluators. Set +instructions+ and the base class calls
+# the judge automatically; override +#evaluate+ for custom logic. See
+# examples/evaluators/ for reference implementations.
 #
 #   class MyEvaluator < Riffer::Evals::Evaluator
 #     instructions "Assess medical accuracy of the response..."
@@ -40,30 +36,15 @@ class Riffer::Evals::Evaluator
   # : (?String?) -> String?
   def self.judge_model: (?String?) -> String?
 
-  # Evaluates an input/output pair.
-  #
-  # The default implementation calls the judge with the class-level +instructions+.
-  # Override this method for custom evaluation logic (e.g. rule-based evaluators).
-  #
-  # [input] the input to evaluate; String or Array of message hashes/Message objects.
-  # [output] the agent's response to evaluate.
-  # [ground_truth] optional reference answer for comparison.
-  # [messages] the full message history from the agent conversation.
-  #
-  # Raises NotImplementedError if neither +instructions+ is set nor +evaluate+ is overridden.
-  #
+  # Evaluates an input/output pair. The default calls the judge with the
+  # class-level +instructions+; override for custom logic (e.g. rule-based
+  # evaluators).
   # --
   # : (input: String | Array[Hash[Symbol, untyped] | Riffer::Messages::Base], output: String, ?ground_truth: String?, ?messages: Array[Riffer::Messages::Base]) -> Riffer::Evals::Result
   def evaluate: (input: String | Array[Hash[Symbol, untyped] | Riffer::Messages::Base], output: String, ?ground_truth: String?, ?messages: Array[Riffer::Messages::Base]) -> Riffer::Evals::Result
 
   private
 
-  # Formats the input for the judge.
-  #
-  # String inputs are passed through as-is.
-  # Array inputs (message hashes or Message objects) are formatted
-  # as labeled role/content pairs separated by blank lines.
-  #
   # --
   # : (String | Array[Hash[Symbol, untyped] | Riffer::Messages::Base]) -> String
   def format_input: (String | Array[Hash[Symbol, untyped] | Riffer::Messages::Base]) -> String
@@ -74,8 +55,7 @@ class Riffer::Evals::Evaluator
   # : () -> Riffer::Evals::Judge
   def judge: () -> Riffer::Evals::Judge
 
-  # Helper to build a Result object.
-  #
+  # Builds a Result for this evaluator.
   # --
   # : (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped]) -> Riffer::Evals::Result
   def result: (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped]) -> Riffer::Evals::Result

data/sig/generated/riffer/evals/evaluator_runner.rbs

@@ -2,10 +2,6 @@
 
 # Orchestrates running evaluators against an agent across multiple scenarios.
 #
-# Accepts an agent class, a list of scenarios, and evaluator classes.
-# Generates agent output for each scenario and runs all evaluators,
-# returning a RunResult with per-scenario details and aggregate scores.
-#
 #   result = Riffer::Evals::EvaluatorRunner.run(
 #     agent: MyAgent,
 #     scenarios: [
@@ -16,30 +12,24 @@
 #   )
 #
 #   result.scores   # => { AnswerRelevancyEvaluator => 0.85 }
-class Riffer::Evals::EvaluatorRunner
-  # Runs evaluators against an agent for the given scenarios.
-  #
-  # [agent] an Agent subclass (not an instance).
-  # [scenarios] array of hashes with +:input+, optional +:ground_truth+, and optional +:context+.
-  # [evaluators] array of Evaluator subclasses to run against each scenario.
-  # [context] optional hash passed to +agent.generate+. Per-scenario +:context+ takes precedence.
-  #
-  # Raises Riffer::ArgumentError if agent is not a Riffer::Agent subclass
-  # or any eval is not a Riffer::Evals::Evaluator subclass.
-  #
+module Riffer::Evals::EvaluatorRunner
+  # Runs evaluators against an agent for the given scenarios. Raises
+  # Riffer::ArgumentError on an invalid agent or evaluator.
   # --
   # : (agent: singleton(Riffer::Agent), scenarios: Array[Hash[Symbol, untyped]], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::RunResult
-  def self.run: (agent: singleton(Riffer::Agent), scenarios: Array[Hash[Symbol, untyped]], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::RunResult
+  def run: (agent: singleton(Riffer::Agent), scenarios: Array[Hash[Symbol, untyped]], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::RunResult
+
+  private
 
   # --
   # : (singleton(Riffer::Agent)) -> void
-  def self.validate_agent!: (singleton(Riffer::Agent)) -> void
+  def validate_agent!: (singleton(Riffer::Agent)) -> void
 
   # --
   # : (Array[singleton(Riffer::Evals::Evaluator)]) -> void
-  def self.validate_evaluators!: (Array[singleton(Riffer::Evals::Evaluator)]) -> void
+  def validate_evaluators!: (Array[singleton(Riffer::Evals::Evaluator)]) -> void
 
   # --
   # : (agent: singleton(Riffer::Agent), scenario: Hash[Symbol, untyped], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::ScenarioResult
-  def self.run_scenario: (agent: singleton(Riffer::Agent), scenario: Hash[Symbol, untyped], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::ScenarioResult
+  def run_scenario: (agent: singleton(Riffer::Agent), scenario: Hash[Symbol, untyped], evaluators: Array[singleton(Riffer::Evals::Evaluator)], ?context: Hash[Symbol, untyped]?) -> Riffer::Evals::ScenarioResult
 end

data/sig/generated/riffer/evals/judge.rbs

@@ -1,19 +1,7 @@
 # Generated from lib/riffer/evals/judge.rb with RBS::Inline
 
-# Executes LLM-as-judge evaluations using the provider infrastructure.
-#
-# The Judge class handles calling an LLM to evaluate agent outputs
-# and parsing the structured response. It uses tool calling internally
-# to get guaranteed structured output from the judge model.
-#
-#   judge = Riffer::Evals::Judge.new(model: "anthropic/claude-opus-4-5-20251101")
-#   result = judge.evaluate(
-#     instructions: "Assess answer relevancy...",
-#     input: "What is Ruby?",
-#     output: "Ruby is a programming language."
-#   )
-#   result[:score]  # => 0.85
-#   result[:reason] # => "The response is relevant..."
+# Executes LLM-as-judge evaluations, using tool calling internally to get
+# structured output from the judge model.
 class Riffer::Evals::Judge
   @provider_options: Hash[Symbol, untyped]
 
@@ -33,20 +21,12 @@ class Riffer::Evals::Judge
   # The model string (provider/model format).
   attr_reader model: String
 
-  # Initializes a new judge.
-  #
+  # Raises Riffer::ArgumentError unless +model+ is "provider/model" format.
   # --
   # : (model: String, ?provider_options: Hash[Symbol, untyped]) -> void
   def initialize: (model: String, ?provider_options: Hash[Symbol, untyped]) -> void
 
-  # Evaluates using the configured LLM.
-  #
-  # Composes system and user messages from the semantic fields:
-  # [instructions] evaluation criteria and scoring rubric.
-  # [input] the original input/question.
-  # [output] the agent's response to evaluate.
-  # [ground_truth] optional reference answer for comparison.
-  #
+  # Evaluates an input/output pair using the configured LLM.
   # --
   # : (instructions: String, input: String, output: String, ?ground_truth: String?) -> Hash[Symbol, untyped]
   def evaluate: (instructions: String, input: String, output: String, ?ground_truth: String?) -> Hash[Symbol, untyped]

data/sig/generated/riffer/evals/result.rbs

@@ -1,19 +1,6 @@
 # Generated from lib/riffer/evals/result.rb with RBS::Inline
 
 # Represents the result of a single evaluation.
-#
-# Contains the score, reason, and metadata from running an evaluator.
-#
-#   result = Riffer::Evals::Result.new(
-#     evaluator: AnswerRelevancyEvaluator,
-#     score: 0.85,
-#     reason: "The response addresses the question directly.",
-#     higher_is_better: true
-#   )
-#
-#   result.score           # => 0.85
-#   result.evaluator       # => AnswerRelevancyEvaluator
-#   result.higher_is_better # => true
 class Riffer::Evals::Result
   # The evaluator class that produced this result.
   attr_reader evaluator: singleton(Riffer::Evals::Evaluator)
@@ -30,10 +17,7 @@ class Riffer::Evals::Result
   # Whether higher scores are better for this evaluator.
   attr_reader higher_is_better: bool
 
-  # Initializes a new evaluation result.
-  #
-  # Raises Riffer::ArgumentError if score is not between 0.0 and 1.0.
-  #
+  # Raises Riffer::ArgumentError if +score+ is not between 0.0 and 1.0.
   # --
   # : (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool) -> void
   def initialize: (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool) -> void

data/sig/generated/riffer/evals/run_result.rbs

@@ -1,20 +1,10 @@
 # Generated from lib/riffer/evals/run_result.rb with RBS::Inline
 
 # Represents the complete result of an evaluation run across multiple scenarios.
-#
-# Contains per-scenario results and provides aggregate scores.
-#
-#   run_result = Riffer::Evals::RunResult.new(
-#     scenario_results: [scenario_result1, scenario_result2]
-#   )
-#
-#   run_result.scores   # => { MyEvaluator => 0.85 }
 class Riffer::Evals::RunResult
   # Per-scenario evaluation results.
   attr_reader scenario_results: Array[Riffer::Evals::ScenarioResult]
 
-  # Initializes a new run result.
-  #
   # --
   # : (scenario_results: Array[Riffer::Evals::ScenarioResult]) -> void
   def initialize: (scenario_results: Array[Riffer::Evals::ScenarioResult]) -> void

data/sig/generated/riffer/evals/scenario_result.rbs

@@ -1,17 +1,6 @@
 # Generated from lib/riffer/evals/scenario_result.rb with RBS::Inline
 
 # Represents the result of evaluating a single scenario.
-#
-# Contains the input, output, ground truth, and individual evaluator results.
-#
-#   scenario_result = Riffer::Evals::ScenarioResult.new(
-#     input: "What is Ruby?",
-#     output: "A programming language.",
-#     ground_truth: "A programming language",
-#     results: [result1, result2]
-#   )
-#
-#   scenario_result.scores  # => { MyEvaluator => 0.85 }
 class Riffer::Evals::ScenarioResult
   # The input that was evaluated.
   attr_reader input: String
@@ -28,8 +17,6 @@ class Riffer::Evals::ScenarioResult
   # The full message history from the agent conversation.
   attr_reader messages: Array[Riffer::Messages::Base]
 
-  # Initializes a new scenario result.
-  #
   # --
   # : (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base]) -> void
   def initialize: (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base]) -> void

data/sig/generated/riffer/evals.rbs

@@ -1,10 +1,4 @@
 # Generated from lib/riffer/evals.rb with RBS::Inline
 
-# Riffer::Evals provides LLM-as-judge evaluation capabilities.
-#
-# Evals allow you to measure the quality of agent outputs using
-# configurable evaluators and scenarios.
-#
-# See Riffer::Evals::Evaluator, Riffer::Evals::EvaluatorRunner, and Riffer::Evals::RunResult.
 module Riffer::Evals
 end

data/sig/generated/riffer/guardrail.rbs

@@ -2,8 +2,6 @@
 
 # Base class for guardrails that process input and output in the agent pipeline.
 #
-# Subclass this to create custom guardrails:
-#
 #   class MyGuardrail < Riffer::Guardrail
 #     def process_input(messages, context:)
 #       # Return pass(messages), transform(modified_messages), or block(reason)
@@ -16,50 +14,29 @@
 #     end
 #   end
 class Riffer::Guardrail
-  # Processes input messages before they are sent to the LLM.
-  #
-  # Override this method in subclasses to implement input processing.
-  #
-  # [messages] the input messages.
-  # [context] optional context passed to the agent.
-  #
+  # 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: (Array[Riffer::Messages::Base], context: untyped) -> Riffer::Guardrails::Result
 
-  # Processes output response after it is received from the LLM.
-  #
-  # Override this method in subclasses to implement output processing.
-  #
-  # [response] the LLM response.
-  # [messages] the conversation messages.
-  # [context] optional context passed to the agent.
-  #
+  # 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: (Riffer::Messages::Assistant, messages: Array[Riffer::Messages::Base], context: untyped) -> Riffer::Guardrails::Result
 
   # Creates a pass result that continues with unchanged data.
-  #
-  # [data] the original data to pass through.
-  #
   # --
   # : (untyped) -> Riffer::Guardrails::Result
   def pass: (untyped) -> Riffer::Guardrails::Result
 
   # Creates a transform result that continues with transformed data.
-  #
-  # [data] the transformed data.
-  #
   # --
   # : (untyped) -> Riffer::Guardrails::Result
   def transform: (untyped) -> Riffer::Guardrails::Result
 
   # Creates a block result that halts execution.
-  #
-  # [reason] the reason for blocking.
-  # [metadata] optional additional information.
-  #
   # --
   # : (String, ?metadata: Hash[Symbol, untyped]?) -> Riffer::Guardrails::Result
   def block: (String, ?metadata: Hash[Symbol, untyped]?) -> Riffer::Guardrails::Result

data/sig/generated/riffer/guardrails/modification.rbs

@@ -1,10 +1,6 @@
 # Generated from lib/riffer/guardrails/modification.rb with RBS::Inline
 
 # Records a guardrail transformation event.
-#
-# When a guardrail transforms data (via +transform+), a Modification is
-# created to record which guardrail made the change, in which phase, and
-# which message indices were affected.
 class Riffer::Guardrails::Modification
   # The guardrail class that transformed data.
   attr_reader guardrail: singleton(Riffer::Guardrail)
@@ -15,12 +11,6 @@ class Riffer::Guardrails::Modification
   # The indices of messages that were changed.
   attr_reader message_indices: Array[Integer]
 
-  # Creates a new modification record.
-  #
-  # [guardrail] the guardrail class that transformed.
-  # [phase] :before or :after.
-  # [message_indices] indices of changed messages.
-  #
   # --
   # : (guardrail: singleton(Riffer::Guardrail), phase: Symbol, message_indices: Array[Integer]) -> void
   def initialize: (guardrail: singleton(Riffer::Guardrail), phase: Symbol, message_indices: Array[Integer]) -> void

data/sig/generated/riffer/guardrails/result.rbs

@@ -1,17 +1,7 @@
 # Generated from lib/riffer/guardrails/result.rb with RBS::Inline
 
-# Represents the result of a guardrail execution.
-#
-# Results can be one of three types:
-# - pass: Continue with the original data unchanged
-# - transform: Continue with transformed data
-# - block: Halt execution with a reason
-#
-# Use the factory methods to create results:
-#
-#   Result.pass(data)
-#   Result.transform(data)
-#   Result.block(reason, metadata: nil)
+# 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: Array[Symbol]
 
@@ -25,38 +15,21 @@ class Riffer::Guardrails::Result
   attr_reader metadata: Hash[Symbol, untyped]?
 
   # Creates a pass result that continues with unchanged data.
-  #
-  # [data] the original data to pass through.
-  #
   # --
   # : (untyped) -> Riffer::Guardrails::Result
   def self.pass: (untyped) -> Riffer::Guardrails::Result
 
   # Creates a transform result that continues with transformed data.
-  #
-  # [data] the transformed data.
-  #
   # --
   # : (untyped) -> Riffer::Guardrails::Result
   def self.transform: (untyped) -> Riffer::Guardrails::Result
 
   # Creates a block result that halts execution.
-  #
-  # [reason] the reason for blocking.
-  # [metadata] optional additional information.
-  #
   # --
   # : (String, ?metadata: Hash[Symbol, untyped]?) -> Riffer::Guardrails::Result
   def self.block: (String, ?metadata: Hash[Symbol, untyped]?) -> Riffer::Guardrails::Result
 
-  # Creates a new result.
-  #
-  # [type] the result type (:pass, :transform, or :block).
-  # [data] the data or reason.
-  # [metadata] optional metadata for block results.
-  #
-  # Raises Riffer::ArgumentError if the result type is invalid.
-  #
+  # Raises Riffer::ArgumentError if +type+ is not :pass, :transform, or :block.
   # --
   # : (Symbol, untyped, ?metadata: Hash[Symbol, untyped]?) -> void
   def initialize: (Symbol, untyped, ?metadata: Hash[Symbol, untyped]?) -> void

data/sig/generated/riffer/guardrails/runner.rbs

@@ -1,13 +1,7 @@
 # Generated from lib/riffer/guardrails/runner.rb with RBS::Inline
 
-# Executes guardrails sequentially and manages the processing pipeline.
-#
-# The runner processes guardrails in order, passing the output of each
-# to the next. If any guardrail blocks, execution stops and a tripwire
-# is returned.
-#
-#   runner = Runner.new(guardrail_configs, phase: :before, context: context)
-#   data, tripwire, modifications = runner.run(messages)
+# 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]]
@@ -18,24 +12,13 @@ class Riffer::Guardrails::Runner
   # The context passed to guardrails.
   attr_reader context: untyped
 
-  # Creates a new runner.
-  #
-  # [guardrail_configs] configs with :class and :options keys.
-  # [phase] :before or :after.
-  # [context] optional context to pass to guardrails.
-  #
   # --
   # : (Array[Hash[Symbol, untyped]], phase: Symbol, ?context: untyped) -> void
   def initialize: (Array[Hash[Symbol, untyped]], phase: Symbol, ?context: untyped) -> void
 
-  # Runs the guardrails sequentially.
-  #
-  # For before phase, data should be an array of messages.
-  # For after phase, data should be a response and messages must be provided.
-  #
-  # [data] the data to process (messages for before, response for after).
-  # [messages] the conversation messages (required for after phase).
-  #
+  # 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: (untyped, ?messages: Array[Riffer::Messages::Base]?) -> [ untyped, Riffer::Guardrails::Tripwire?, Array[Riffer::Guardrails::Modification] ]

data/sig/generated/riffer/guardrails/tripwire.rbs

@@ -1,16 +1,6 @@
 # Generated from lib/riffer/guardrails/tripwire.rb with RBS::Inline
 
 # Captures information about a blocked guardrail execution.
-#
-# When a guardrail blocks execution, a Tripwire is created to record
-# the reason, which guardrail triggered it, and which phase it occurred in.
-#
-#   tripwire = Tripwire.new(
-#     reason: "PII detected in input",
-#     guardrail: PiiRedactor,
-#     phase: :before,
-#     metadata: { detected_types: [:email, :phone] }
-#   )
 class Riffer::Guardrails::Tripwire
   PHASES: Array[Symbol]
 
@@ -26,15 +16,7 @@ class Riffer::Guardrails::Tripwire
   # Optional metadata about the block.
   attr_reader metadata: Hash[Symbol, untyped]?
 
-  # Creates a new tripwire.
-  #
-  # [reason] the reason for blocking.
-  # [guardrail] the guardrail class that blocked.
-  # [phase] :before or :after.
-  # [metadata] optional additional information.
-  #
-  # Raises Riffer::ArgumentError if the phase is invalid.
-  #
+  # Raises Riffer::ArgumentError if +phase+ is invalid.
   # --
   # : (reason: String, guardrail: singleton(Riffer::Guardrail), phase: Symbol, ?metadata: Hash[Symbol, untyped]?) -> void
   def initialize: (reason: String, guardrail: singleton(Riffer::Guardrail), phase: Symbol, ?metadata: Hash[Symbol, untyped]?) -> void

data/sig/generated/riffer/guardrails.rbs

@@ -1,9 +1,7 @@
 # Generated from lib/riffer/guardrails.rb with RBS::Inline
 
-# Namespace module for guardrail components.
-#
-# Guardrails provide pre-processing of input messages and post-processing
-# of output responses in the agent pipeline.
+# Namespace for guardrail components that pre-process input and post-process
+# output in the agent pipeline.
 module Riffer::Guardrails
   PHASES: Array[Symbol]
 end

data/sig/generated/riffer/helpers/call_or_value.rbs

@@ -1,9 +1,10 @@
 # Generated from lib/riffer/helpers/call_or_value.rb with RBS::Inline
 
-# Resolves the "Proc-or-value" idiom: if +thing+ is a Proc, calls it
-# (passing +context+ when its arity is non-zero); otherwise returns
-# +thing+ unchanged. When +thing+ is +nil+, returns +default+.
+# Resolves the Proc-or-value idiom.
 module Riffer::Helpers::CallOrValue
+  # 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: (untyped, ?context: untyped, ?default: untyped) -> untyped
 end

data/sig/generated/riffer/helpers/class_name_converter.rbs

@@ -8,5 +8,5 @@ module Riffer::Helpers::ClassNameConverter
   #
   # --
   # : (String, ?separator: String) -> String
-  def class_name_to_path: (String, ?separator: String) -> String
+  def convert: (String, ?separator: String) -> String
 end

data/sig/generated/riffer/helpers/dependencies.rbs

@@ -1,17 +1,13 @@
 # Generated from lib/riffer/helpers/dependencies.rb with RBS::Inline
 
-# Helper module for lazy loading gem dependencies.
-#
-# Used by providers to load their required gems only when needed.
+# Lazy-loads gem dependencies — used by providers to load required gems only
+# when needed.
 module Riffer::Helpers::Dependencies
   # Raised when a required gem cannot be loaded.
   class LoadError < ::LoadError
   end
 
-  # Requires a gem by name, raising a helpful error if it is not installed.
-  #
-  # Raises LoadError if the gem cannot be required.
-  #
+  # Requires a gem by name; raises LoadError if it isn't installed.
   # --
   # : (String) -> true
   def depends_on: (String) -> true

data/sig/generated/riffer/helpers.rbs

@@ -1,9 +1,4 @@
 # Generated from lib/riffer/helpers.rb with RBS::Inline
 
-# Namespace for shared helper modules in the Riffer framework.
-#
-# Helpers provide reusable functionality across the library:
-# - Riffer::Helpers::ClassNameConverter - Class name to path conversion
-# - Riffer::Helpers::Dependencies - Lazy gem dependency loading
 module Riffer::Helpers
 end

data/sig/generated/riffer/mcp/authenticated_tool.rbs

@@ -1,17 +1,18 @@
 # Generated from lib/riffer/mcp/authenticated_tool.rb with RBS::Inline
 
-# Wraps MCP-generated tool classes so +tools/call+ uses +Riffer.config.mcp.credentials+
-# per invocation while delegating metadata to the inner class.
+# Wraps MCP-generated tool classes so +tools/call+ resolves
+# +Riffer.config.mcp.credentials+ per invocation, delegating metadata to the
+# inner class.
 module Riffer::Mcp::AuthenticatedTool
   # Returns one wrapper class per inner tool, sharing +manifest+ and +matched_tags+.
   #
   # --
   # : (Array[singleton(Riffer::Tool)], Riffer::Mcp::Manifest, Array[Symbol]) -> Array[singleton(Riffer::Tool)]
-  def self.wrap_all: (Array[singleton(Riffer::Tool)], Riffer::Mcp::Manifest, Array[Symbol]) -> Array[singleton(Riffer::Tool)]
+  def wrap_all: (Array[singleton(Riffer::Tool)], Riffer::Mcp::Manifest, Array[Symbol]) -> Array[singleton(Riffer::Tool)]
 
   # --
   # : (singleton(Riffer::Tool), Riffer::Mcp::Manifest, Array[Symbol]) -> singleton(Riffer::Tool)
   #  Class.new(Riffer::Tool) is typed as ::Class by steep — it cannot verify the subtype
   #  relationship for dynamically created anonymous classes, so the ignore is required.
-  def self.wrap_one: (singleton(Riffer::Tool), Riffer::Mcp::Manifest, Array[Symbol]) -> singleton(Riffer::Tool)
+  def wrap_one: (singleton(Riffer::Tool), Riffer::Mcp::Manifest, Array[Symbol]) -> singleton(Riffer::Tool)
 end

data/sig/generated/riffer/mcp/client.rbs

@@ -1,28 +1,17 @@
 # Generated from lib/riffer/mcp/client.rb with RBS::Inline
 
-# Thin wrapper around the MCP Ruby SDK client (mcp gem v0.8+).
-#
-# Resolves headers (if a Proc) once at initialization, then provides
-# +tools_list+ and +tools_call+. Used for discovery (+Manifest#discovery_headers+)
-# and for +tools/call+ when no +credentials+ proc is configured.
-#
-# MCP gem API used:
-#   MCP::Client::HTTP.new(url:, headers:)  — HTTP transport (requires faraday)
-#   MCP::Client.new(transport:)            — client
-#   client.tools                           — Array<MCP::Client::Tool>
-#   client.call_tool(tool:, arguments:)    — raw JSON-RPC response Hash
+# 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
-  include Riffer::Helpers::Dependencies
-
   @client: untyped
 
   # --
   # : (endpoint: String, ?headers: (Hash[String, String] | Proc), ?client: untyped?) -> void
   def initialize: (endpoint: String, ?headers: Hash[String, String] | Proc, ?client: untyped?) -> void
 
-  # Returns an array of tool definition hashes, each with +:name+, +:description+,
-  # and +:input_schema+ keys.
-  #
+  # Returns tool definition hashes with +:name+, +:description+, and
+  # +:input_schema+ keys.
   # --
   # : () -> Array[Hash[Symbol, untyped]]
   def tools_list: () -> Array[Hash[Symbol, untyped]]
@@ -32,4 +21,9 @@ class Riffer::Mcp::Client
   # --
   # : (String, ?Hash[untyped, untyped]) -> String
   def tools_call: (String, ?Hash[untyped, untyped]) -> String
+
+  private
+
+  # : (String) -> true
+  def depends_on: (String) -> true
 end

data/sig/generated/riffer/mcp/manifest.rbs

@@ -1,25 +1,25 @@
 # Generated from lib/riffer/mcp/manifest.rb with RBS::Inline
 
-# Riffer::Mcp::Manifest holds the configuration for a single MCP server.
-#
-# +name+                - String identifier used as the registration key and generated-agent identifier.
-# +tags+                - Array[Symbol]; normalized to symbols at construction time.
-# +endpoint+            - String HTTPS URL passed to the MCP transport.
-# +discovery_headers+   - Hash or Proc; resolved once when building the discovery client for +tools/list+.
-# +credentials_scope+  - Optional symbol hint: +:global+, +:tenant+, +:user+ — documents whether
-#   invocation credentials are expected to depend on tenant and/or user keys in +context+ (no ids stored).
-#   Apps may treat +:user+ as "user in tenant" and pass both keys in +context+.
+# 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
 
+  # Tags for matching +use_mcp+.
   attr_reader tags: Array[Symbol]
 
+  # HTTPS URL passed to the MCP transport.
   attr_reader endpoint: String
 
+  # Headers (or a Proc) resolved once when building the discovery client.
   attr_reader discovery_headers: (Hash[String, untyped] | ::Proc)?
 
+  # Optional hint (+:global+/+:tenant+/+:user+) for whether invocation
+  # credentials depend on tenant/user keys in +context+.
   attr_reader credentials_scope: Symbol?
 
+  # Raises Riffer::ArgumentError unless +name+ is present and +endpoint+ is a
+  # valid HTTPS URL.
   # --
   # : (name: String, endpoint: String, ?tags: Array[untyped]?, ?discovery_headers: (Hash[String, untyped] | ::Proc)?, ?credentials_scope: (String | Symbol)?) -> void
   def initialize: (name: String, endpoint: String, ?tags: Array[untyped]?, ?discovery_headers: (Hash[String, untyped] | ::Proc)?, ?credentials_scope: (String | Symbol)?) -> void