riffer 0.41.0 → 0.43.0

data/lib/riffer/registrable.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+# Registry of a class's named direct subclasses, keyed by identifier. Extend it
+# onto a base class to look up subclasses in constant time via +find+ and +all+.
+#
+#   class Riffer::Tool
+#     extend Riffer::Registrable
+#   end
+#
+#   Riffer::Tool.find("weather_tool") # => WeatherTool
+#
+# @rbs module-self Class
+module Riffer::Registrable
+  # @rbs @identifier_registry: Hash[String, Class]?
+
+  # Finds a registered subclass by identifier, or +nil+ when none matches.
+  # Only *named direct* subclasses are registered: grandchildren are not
+  # visible to a grandparent's +find+ (call +find+ on their direct parent
+  # instead), anonymous classes are never registered, and duplicate identifiers
+  # raise Riffer::DuplicateIdentifierError at first lookup.
+  #
+  #--
+  #: (String | Symbol) -> Class?
+  def find(identifier)
+    identifier_registry[identifier.to_s]
+  end
+
+  # Returns all registered subclasses. Only *named direct* subclasses are
+  # registered: grandchildren are not included (call +all+ on their direct
+  # parent instead), anonymous classes are never registered, and duplicate
+  # identifiers raise Riffer::DuplicateIdentifierError at first lookup.
+  #
+  #--
+  #: () -> Array[Class]
+  def all
+    identifier_registry.values
+  end
+
+  private
+
+  # Ruby invokes +inherited+ with +self+ bound to the direct superclass — the
+  # only registry the new subclass joins — so busting self's memo is exactly
+  # sufficient.
+  #--
+  #: (Class) -> void
+  def inherited(subclass)
+    super
+    @identifier_registry = nil
+  end
+
+  #--
+  #: () -> Hash[String, Class]
+  def identifier_registry
+    @identifier_registry ||= build_identifier_registry
+  end
+
+  #--
+  #: () -> Hash[String, Class]
+  def build_identifier_registry
+    registry = {} #: Hash[String, Class]
+    subclasses.each_with_object(registry) do |subclass, acc|
+      # Anonymous classes are skipped even with an explicit identifier — the
+      # MCP factory and serializer shells synthesize short-lived anonymous
+      # classes whose registration would flake with GC timing.
+      next if Riffer::Helpers::Identifier.for(subclass).empty?
+
+      candidate = subclass #: untyped
+      key = candidate.identifier.to_s
+      next if key.strip.empty?
+
+      existing = acc[key]
+      if existing
+        raise Riffer::DuplicateIdentifierError,
+              "Duplicate identifier #{key.inspect} for #{existing} and #{subclass}"
+      end
+
+      acc[key] = subclass
+    end.freeze
+  end
+end

data/lib/riffer/tool.rb

@@ -21,6 +21,7 @@ require "timeout"
 #
 class Riffer::Tool
   extend Riffer::Tools::Toolable
+  extend Riffer::Registrable
 
   kind :tool
 
@@ -55,19 +56,23 @@ class Riffer::Tool
     Riffer::Tools::Response.error(message, type: type)
   end
 
-  # Executes the tool with validation and timeout (used by Agent).
-  #
-  # Raises Riffer::ValidationError if validation fails.
-  # Raises Riffer::TimeoutError if execution exceeds the configured timeout.
-  # Raises Riffer::Error if the tool does not return a Response object.
+  # Executes the tool with validation and timeout, folding every +StandardError+
+  # into an error Response. Anything outside +StandardError+ — an unimplemented
+  # +#call+ above all — still propagates, because a broken tool is a broken
+  # deploy rather than a bad request.
   #
   #--
   #: (context: Riffer::Agent::Context?, **untyped) -> Riffer::Tools::Response
   def call_with_validation(context:, **kwargs)
     params_builder = self.class.params
-    validated_args = params_builder ? params_builder.validate(kwargs) : kwargs
 
-    result = Timeout.timeout(self.class.timeout) do
+    begin
+      validated_args = params_builder ? params_builder.validate(kwargs) : kwargs
+    rescue Riffer::ValidationError => e
+      return Riffer::Tools::Response.error(e.message, type: :validation_error)
+    end
+
+    result = Timeout.timeout(self.class.timeout, Riffer::TimeoutError) do
       call(context: context, **validated_args) #: untyped
     end
 
@@ -76,7 +81,18 @@ class Riffer::Tool
     end
 
     result
-  rescue Timeout::Error
-    raise Riffer::TimeoutError, "Tool execution timed out after #{self.class.timeout} seconds"
+  rescue Riffer::TimeoutError
+    Riffer::Tools::Response.error(
+      "Tool execution timed out after #{self.class.timeout} seconds",
+      type: :timeout_error,
+    )
+  rescue Riffer::ToolExecutionError => e
+    Riffer::Tools::Response.error(e.message, type: :execution_error)
+  rescue StandardError => e
+    Riffer::Tools::Response.error(
+      "Error executing tool: #{e.class}: #{e.message}",
+      type: :unhandled_error,
+      exception: e,
+    )
   end
 end

data/lib/riffer/tools/response.rb

@@ -28,6 +28,10 @@ class Riffer::Tools::Response
   # The error type, or +nil+ on success.
   attr_reader :error_type #: Symbol?
 
+  # The exception an unhandled failure was folded from, or +nil+. Kept out of
+  # every serialized form so it never reaches an LLM or a message payload.
+  attr_reader :exception #: Exception?
+
   # Creates a success response.
   #
   # Raises Riffer::ArgumentError if format is invalid.
@@ -62,9 +66,9 @@ class Riffer::Tools::Response
   # Creates an error response.
   #
   #--
-  #: (String, ?type: Symbol) -> Riffer::Tools::Response
-  def self.error(message, type: :execution_error)
-    new(content: message, success: false, error_message: message, error_type: type)
+  #: (String, ?type: Symbol, ?exception: Exception?) -> Riffer::Tools::Response
+  def self.error(message, type: :execution_error, exception: nil)
+    new(content: message, success: false, error_message: message, error_type: type, exception: exception)
   end
 
   # Returns true if the tool execution succeeded.
@@ -88,11 +92,12 @@ class Riffer::Tools::Response
   private
 
   #--
-  #: (content: String, success: bool, ?error_message: String?, ?error_type: Symbol?) -> void
-  def initialize(content:, success:, error_message: nil, error_type: nil)
+  #: (content: String, success: bool, ?error_message: String?, ?error_type: Symbol?, ?exception: Exception?) -> void
+  def initialize(content:, success:, error_message: nil, error_type: nil, exception: nil)
     @content = content
     @success = success
     @error_message = error_message
     @error_type = error_type
+    @exception = exception
   end
 end

data/lib/riffer/tools/runtime.rb

@@ -88,19 +88,20 @@ class Riffer::Tools::Runtime
     tool_instance = tool_class.new
     arguments = parse_arguments(tool_call.arguments)
 
+    unless arguments.is_a?(Hash)
+      return Riffer::Tools::Response.error(
+        "Invalid JSON in tool arguments: expected an object, got #{arguments.class}",
+        type: :validation_error,
+      )
+    end
+
     tool_instance.call_with_validation(context: context, **arguments)
-  rescue Riffer::TimeoutError => e
-    Riffer::Tools::Response.error(e.message, type: :timeout_error)
-  rescue Riffer::ValidationError => e
-    Riffer::Tools::Response.error(e.message, type: :validation_error)
-  rescue Riffer::ToolExecutionError => e
-    Riffer::Tools::Response.error(e.message, type: :execution_error)
-  rescue RuntimeError => e
-    Riffer::Tools::Response.error("Error executing tool: #{e.message}", type: :execution_error)
+  rescue JSON::ParserError => e
+    Riffer::Tools::Response.error("Invalid JSON in tool arguments: #{e.message}", type: :validation_error)
   end
 
   #--
-  #: (String?) -> Hash[Symbol, untyped]
+  #: (String?) -> untyped
   def parse_arguments(arguments)
     return {} if arguments.nil? || arguments.empty?
 
@@ -144,13 +145,21 @@ class Riffer::Tools::Runtime
     tags.transform_keys { |key| "riffer.tag.#{key}" }
   end
 
-  # A returned error Response is a handled outcome, so its status stays unset —
-  # an error span status is reserved for a raised exception.
+  # A deliberate error Response is a handled outcome, so its status stays unset.
+  # An error status is reserved for a Response carrying the exception it was
+  # folded from — the tool failed for a reason nobody anticipated.
   #--
   #: ((Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span), Riffer::Tools::Response) -> void
   def record_tool_outcome(span, result)
     error_type = result.error_type
     span.set_attribute("error.type", error_type.to_s) if error_type
+
+    exception = result.exception
+    if exception
+      span.record_exception(exception)
+      span.error!(exception.message)
+    end
+
     capture_tool_result(span, result)
   end
 

data/lib/riffer/tools/toolable.rb

@@ -15,6 +15,7 @@
 #     end
 #   end
 #
+# @rbs module-self Module
 module Riffer::Tools::Toolable
   # @rbs self.@extenders: Array[Module]?
   # @rbs @description: String?
@@ -57,9 +58,7 @@ module Riffer::Tools::Toolable
   #--
   #: (?String?) -> String
   def identifier(value = nil)
-    if value.nil?
-      return @identifier || Riffer::Helpers::ClassNameConverter.convert(Module.instance_method(:name).bind_call(self))
-    end
+    return @identifier || Riffer::Helpers::Identifier.for(self) if value.nil?
 
     @identifier = value.to_s
   end

data/lib/riffer/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Riffer
-  VERSION = "0.41.0" #: String
+  VERSION = "0.43.0" #: String
 end

data/lib/riffer.rb

@@ -26,12 +26,17 @@ module Riffer
   # Raised when tool parameter validation fails.
   class ValidationError < Error; end
 
-  # Raised when tool execution times out.
+  # Raised inside a tool's +call+ when execution exceeds the configured
+  # timeout. Rescue it in the tool to clean up; otherwise it becomes a
+  # +:timeout_error+ response.
   class TimeoutError < Error; end
 
   # Raised when a tool encounters an expected execution error.
   class ToolExecutionError < Error; end
 
+  # Raised when two registered subclasses share the same identifier.
+  class DuplicateIdentifierError < Error; end
+
   # Returns the Riffer configuration.
   #
   #--

data/sig/generated/riffer/agent.rbs

@@ -11,6 +11,8 @@
 #   agent = MyAgent.new
 #   agent.generate('Hello!')
 class Riffer::Agent
+  extend Riffer::Registrable
+
   self.@config: Riffer::Agent::Config?
 
   INTERRUPT_MAX_STEPS: Symbol
@@ -104,18 +106,6 @@ class Riffer::Agent
   # : () ?{ (Riffer::Skills::Config) [self: Riffer::Skills::Config] -> void } -> Riffer::Skills::Config?
   def self.skills: () ?{ (Riffer::Skills::Config) [self: Riffer::Skills::Config] -> void } -> Riffer::Skills::Config?
 
-  # Finds an agent class by identifier.
-  #
-  # --
-  # : (String) -> singleton(Riffer::Agent)?
-  def self.find: (String) -> singleton(Riffer::Agent)?
-
-  # Returns all agent subclasses.
-  #
-  # --
-  # : () -> Array[singleton(Riffer::Agent)]
-  def self.all: () -> Array[singleton(Riffer::Agent)]
-
   # Generates a response using a new agent instance.
   # --
   # : (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?context: Hash[Symbol, untyped]?, ?tags: Hash[(String | Symbol), untyped]) -> Riffer::Agent::Response

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

@@ -0,0 +1,19 @@
+# Generated from lib/riffer/helpers/identifier.rb with RBS::Inline
+
+# Helper module for deriving snake_case identifiers from class names.
+module Riffer::Helpers::Identifier
+  # Derives a snake_case identifier from a class name string.
+  #
+  # --
+  # : (String?) -> String
+  def derive: (String?) -> String
+
+  # 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: (Module) -> String
+end

data/sig/generated/riffer/messages/tool.rbs

@@ -11,7 +11,8 @@ class Riffer::Messages::Tool < Riffer::Messages::Base
   # The error message if the tool execution failed.
   attr_reader error: String?
 
-  # The type of error (:unknown_tool, :validation_error, :execution_error, :timeout_error).
+  # The type of error (:unknown_tool, :validation_error, :execution_error,
+  # :timeout_error, :unhandled_error).
   attr_reader error_type: Symbol?
 
   # --

data/sig/generated/riffer/providers/base.rbs

@@ -5,6 +5,8 @@
 # +extract_token_usage+, +extract_content+, +extract_tool_calls+) and the base
 # class orchestrates them.
 class Riffer::Providers::Base
+  self.@semconv_provider_name: String?
+
   @client: untyped
 
   @current_model: String?

data/sig/generated/riffer/registrable.rbs

@@ -0,0 +1,51 @@
+# Generated from lib/riffer/registrable.rb with RBS::Inline
+
+# Registry of a class's named direct subclasses, keyed by identifier. Extend it
+# onto a base class to look up subclasses in constant time via +find+ and +all+.
+#
+#   class Riffer::Tool
+#     extend Riffer::Registrable
+#   end
+#
+#   Riffer::Tool.find("weather_tool") # => WeatherTool
+#
+# @rbs module-self Class
+module Riffer::Registrable : Class
+  @identifier_registry: Hash[String, Class]?
+
+  # Finds a registered subclass by identifier, or +nil+ when none matches.
+  # Only *named direct* subclasses are registered: grandchildren are not
+  # visible to a grandparent's +find+ (call +find+ on their direct parent
+  # instead), anonymous classes are never registered, and duplicate identifiers
+  # raise Riffer::DuplicateIdentifierError at first lookup.
+  #
+  # --
+  # : (String | Symbol) -> Class?
+  def find: (String | Symbol) -> Class?
+
+  # Returns all registered subclasses. Only *named direct* subclasses are
+  # registered: grandchildren are not included (call +all+ on their direct
+  # parent instead), anonymous classes are never registered, and duplicate
+  # identifiers raise Riffer::DuplicateIdentifierError at first lookup.
+  #
+  # --
+  # : () -> Array[Class]
+  def all: () -> Array[Class]
+
+  private
+
+  # Ruby invokes +inherited+ with +self+ bound to the direct superclass — the
+  # only registry the new subclass joins — so busting self's memo is exactly
+  # sufficient.
+  # --
+  # : (Class) -> void
+  def inherited: (Class) -> void
+
+  # --
+  # : () -> Hash[String, Class]
+  def identifier_registry: () -> Hash[String, Class]
+
+  # --
+  # : () -> Hash[String, Class]
+  def build_identifier_registry: () -> Hash[String, Class]
+end

data/sig/generated/riffer/tool.rbs

@@ -18,6 +18,8 @@
 class Riffer::Tool
   extend Riffer::Tools::Toolable
 
+  extend Riffer::Registrable
+
   # Executes the tool with the given arguments.
   # --
   # : (context: Riffer::Agent::Context?, **untyped) -> Riffer::Tools::Response
@@ -41,11 +43,10 @@ class Riffer::Tool
   # : (String, ?type: Symbol) -> Riffer::Tools::Response
   def error: (String, ?type: Symbol) -> Riffer::Tools::Response
 
-  # Executes the tool with validation and timeout (used by Agent).
-  #
-  # Raises Riffer::ValidationError if validation fails.
-  # Raises Riffer::TimeoutError if execution exceeds the configured timeout.
-  # Raises Riffer::Error if the tool does not return a Response object.
+  # Executes the tool with validation and timeout, folding every +StandardError+
+  # into an error Response. Anything outside +StandardError+ — an unimplemented
+  # +#call+ above all — still propagates, because a broken tool is a broken
+  # deploy rather than a bad request.
   #
   # --
   # : (context: Riffer::Agent::Context?, **untyped) -> Riffer::Tools::Response

data/sig/generated/riffer/tools/response.rbs

@@ -24,6 +24,10 @@ class Riffer::Tools::Response
   # The error type, or +nil+ on success.
   attr_reader error_type: Symbol?
 
+  # The exception an unhandled failure was folded from, or +nil+. Kept out of
+  # every serialized form so it never reaches an LLM or a message payload.
+  attr_reader exception: Exception?
+
   # Creates a success response.
   #
   # Raises Riffer::ArgumentError if format is invalid.
@@ -47,8 +51,8 @@ class Riffer::Tools::Response
   # Creates an error response.
   #
   # --
-  # : (String, ?type: Symbol) -> Riffer::Tools::Response
-  def self.error: (String, ?type: Symbol) -> Riffer::Tools::Response
+  # : (String, ?type: Symbol, ?exception: Exception?) -> Riffer::Tools::Response
+  def self.error: (String, ?type: Symbol, ?exception: Exception?) -> Riffer::Tools::Response
 
   # Returns true if the tool execution succeeded.
   # --
@@ -69,6 +73,6 @@ class Riffer::Tools::Response
   private
 
   # --
-  # : (content: String, success: bool, ?error_message: String?, ?error_type: Symbol?) -> void
-  def initialize: (content: String, success: bool, ?error_message: String?, ?error_type: Symbol?) -> void
+  # : (content: String, success: bool, ?error_message: String?, ?error_type: Symbol?, ?exception: Exception?) -> void
+  def initialize: (content: String, success: bool, ?error_message: String?, ?error_type: Symbol?, ?exception: Exception?) -> void
 end

data/sig/generated/riffer/tools/runtime.rbs

@@ -44,8 +44,8 @@ class Riffer::Tools::Runtime
   def dispatch_tool_call: (Riffer::Messages::Assistant::ToolCall, tools: Array[singleton(Riffer::Tool)], context: Riffer::Agent::Context?, ?assistant_message: Riffer::Messages::Assistant?) -> Riffer::Tools::Response
 
   # --
-  # : (String?) -> Hash[Symbol, untyped]
-  def parse_arguments: (String?) -> Hash[Symbol, untyped]
+  # : (String?) -> untyped
+  def parse_arguments: (String?) -> untyped
 
   # Emitted outside +around_tool_call+ so host enrichment spans nest beneath it.
   # --
@@ -62,8 +62,9 @@ class Riffer::Tools::Runtime
   # : (Hash[String, String]) -> Hash[String, String]
   def tag_attributes: (Hash[String, String]) -> Hash[String, String]
 
-  # A returned error Response is a handled outcome, so its status stays unset —
-  # an error span status is reserved for a raised exception.
+  # A deliberate error Response is a handled outcome, so its status stays unset.
+  # An error status is reserved for a Response carrying the exception it was
+  # folded from — the tool failed for a reason nobody anticipated.
   # --
   # : ((Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span), Riffer::Tools::Response) -> void
   def record_tool_outcome: (Riffer::Tracing::Otel::Span | Riffer::Tracing::NoOp::Span, Riffer::Tools::Response) -> void

data/sig/generated/riffer/tools/toolable.rbs

@@ -13,7 +13,9 @@
 #       required :input, String
 #     end
 #   end
-module Riffer::Tools::Toolable
+#
+# @rbs module-self Module
+module Riffer::Tools::Toolable : Module
   @kind: Symbol?
 
   @params_builder: Riffer::Params?

data/sig/generated/riffer.rbs

@@ -15,7 +15,9 @@ module Riffer
   class ValidationError < Error
   end
 
-  # Raised when tool execution times out.
+  # Raised inside a tool's +call+ when execution exceeds the configured
+  # timeout. Rescue it in the tool to clean up; otherwise it becomes a
+  # +:timeout_error+ response.
   class TimeoutError < Error
   end
 
@@ -23,6 +25,10 @@ module Riffer
   class ToolExecutionError < Error
   end
 
+  # Raised when two registered subclasses share the same identifier.
+  class DuplicateIdentifierError < Error
+  end
+
   # Returns the Riffer configuration.
   #
   # --

data/sig/manual/riffer/agent.rbs

@@ -0,0 +1,7 @@
+# `Riffer::Agent` extends `Riffer::Registrable`, whose generic signatures return
+# `Class`. Narrow them here so callers get the agent singleton type back.
+class Riffer::Agent
+  def self.find: (String | Symbol) -> singleton(Riffer::Agent)?
+
+  def self.all: () -> Array[singleton(Riffer::Agent)]
+end

data/sig/manual/riffer/helpers/identifier.rbs

@@ -0,0 +1,5 @@
+# `Riffer::Helpers::Identifier` uses `extend self`; rbs-inline doesn't emit
+# that, so re-extend here to expose its instance methods as singleton methods.
+module Riffer::Helpers::Identifier
+  extend ::Riffer::Helpers::Identifier
+end

data/sig/manual/riffer/tool.rbs

@@ -0,0 +1,7 @@
+# `Riffer::Tool` extends `Riffer::Registrable`, whose generic signatures return
+# `Class`. Narrow them here so callers get the tool singleton type back.
+class Riffer::Tool
+  def self.find: (String | Symbol) -> singleton(Riffer::Tool)?
+
+  def self.all: () -> Array[singleton(Riffer::Tool)]
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer
 version: !ruby/object:Gem::Version
-  version: 0.41.0
+  version: 0.43.0
 platform: ruby
 authors:
 - Jake Bottrall
@@ -41,19 +41,15 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- ".agents/architecture.md"
-- ".agents/code-style.md"
-- ".agents/providers.md"
-- ".agents/rbs-inline.md"
-- ".agents/testing.md"
 - ".bundle/config"
+- ".claude/CLAUDE.md"
+- ".claude/rules/comments.md"
+- ".claude/rules/rbs-inline.md"
 - ".release-please-config.json"
 - ".release-please-manifest.json"
 - ".rubocop.yml"
 - ".ruby-version"
-- AGENTS.md
 - CHANGELOG.md
-- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - Guardfile
 - LICENSE.txt
@@ -123,8 +119,8 @@ files:
 - lib/riffer/helpers.rb
 - lib/riffer/helpers/boolean.rb
 - lib/riffer/helpers/call_or_value.rb
-- lib/riffer/helpers/class_name_converter.rb
 - lib/riffer/helpers/dependencies.rb
+- lib/riffer/helpers/identifier.rb
 - lib/riffer/mcp.rb
 - lib/riffer/mcp/authenticated_tool.rb
 - lib/riffer/mcp/client.rb
@@ -157,6 +153,7 @@ files:
 - lib/riffer/providers/open_router.rb
 - lib/riffer/providers/repository.rb
 - lib/riffer/providers/token_usage.rb
+- lib/riffer/registrable.rb
 - lib/riffer/runner.rb
 - lib/riffer/runner/fibers.rb
 - lib/riffer/runner/sequential.rb
@@ -242,8 +239,8 @@ files:
 - sig/generated/riffer/helpers.rbs
 - sig/generated/riffer/helpers/boolean.rbs
 - sig/generated/riffer/helpers/call_or_value.rbs
-- sig/generated/riffer/helpers/class_name_converter.rbs
 - sig/generated/riffer/helpers/dependencies.rbs
+- sig/generated/riffer/helpers/identifier.rbs
 - sig/generated/riffer/mcp.rbs
 - sig/generated/riffer/mcp/authenticated_tool.rbs
 - sig/generated/riffer/mcp/client.rbs
@@ -276,6 +273,7 @@ files:
 - sig/generated/riffer/providers/open_router.rbs
 - sig/generated/riffer/providers/repository.rbs
 - sig/generated/riffer/providers/token_usage.rbs
+- sig/generated/riffer/registrable.rbs
 - sig/generated/riffer/runner.rbs
 - sig/generated/riffer/runner/fibers.rbs
 - sig/generated/riffer/runner/sequential.rbs
@@ -322,20 +320,22 @@ files:
 - sig/generated/riffer/version.rbs
 - sig/manifest.yaml
 - sig/manual/riffer.rbs
+- sig/manual/riffer/agent.rbs
 - sig/manual/riffer/agent/run.rbs
 - sig/manual/riffer/agent/serializer.rbs
 - sig/manual/riffer/agent/session/repair.rbs
 - sig/manual/riffer/evals/evaluator_runner.rbs
 - sig/manual/riffer/helpers/boolean.rbs
 - sig/manual/riffer/helpers/call_or_value.rbs
-- sig/manual/riffer/helpers/class_name_converter.rbs
 - sig/manual/riffer/helpers/dependencies.rbs
+- sig/manual/riffer/helpers/identifier.rbs
 - sig/manual/riffer/mcp.rbs
 - sig/manual/riffer/mcp/authenticated_tool.rbs
 - sig/manual/riffer/mcp/registry.rbs
 - sig/manual/riffer/mcp/tool_factory.rbs
 - sig/manual/riffer/providers.rbs
 - sig/manual/riffer/providers/repository.rbs
+- sig/manual/riffer/tool.rbs
 - sig/manual/riffer/tracing.rbs
 - sig/manual/riffer/tracing/capture.rbs
 - sig/manual/riffer/tracing/no_op.rbs