ruby_llm 2.1.1 → 2.2.0

data/lib/ruby_llm/skill/loader.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class Skill
+    # The +load_skill+ tool a chat with skills gives the model. It returns a
+    # skill's instructions, or one of the files the instructions mention,
+    # and never leaves the skill's folder. Every request also lists the
+    # skills, through #listing, so the model knows what it can load.
+    class Loader < Tool # :nodoc:
+      MAX_FILE_SIZE = 256 * 1024
+      MOUNT = 'skills'
+
+      def self.tool_name
+        'load_skill'
+      end
+
+      def self.mount_path(skill)
+        "#{MOUNT}/#{skill.name}"
+      end
+
+      def self.resource_name(skill, file)
+        file = file.to_s
+        return if file.strip.empty? || file == FILE
+
+        file.delete_prefix("#{MOUNT}/#{skill}/")
+      end
+
+      def initialize(skills:, code_execution:)
+        super()
+        @skills = skills
+        @code_execution = code_execution
+      end
+
+      def description
+        "Loads a skill's instructions, or a file inside a skill's folder that its instructions mention. " \
+          'Call it with only skill to get the instructions before following a skill, ' \
+          'and with file, a path relative to the skill folder, to read one of its files.'
+      end
+
+      def parameters_schema
+        {
+          'type' => 'object',
+          'properties' => {
+            'skill' => { 'type' => 'string', 'description' => 'The name of the skill' },
+            'file' => { 'type' => 'string',
+                        'description' => 'A file path relative to the skill folder. Leave it out for the instructions' }
+          },
+          'required' => %w[skill],
+          'additionalProperties' => false
+        }
+      end
+
+      def skill?(name)
+        @skills.call.any? { |skill| skill.name == name }
+      end
+
+      def listing
+        [
+          'You have skills: folders of instructions, scripts, and files for specific tasks. ' \
+          'When a task matches a skill, call load_skill with its name and follow the instructions it ' \
+          'returns. Load the files the instructions mention with load_skill as well, one at a time.',
+          scripts_note,
+          "<skills>\n#{@skills.call.map { |skill| "- #{skill.name}: #{skill.description}" }.join("\n")}\n</skills>"
+        ].join("\n\n")
+      end
+
+      def execute(skill:, file: nil)
+        found = @skills.call.find { |candidate| candidate.name == skill.to_s }
+        return { error: "No skill named #{skill}. Skills: #{@skills.call.map(&:name).join(', ')}" } unless found
+
+        resource = self.class.resource_name(found.name, file)
+        resource ? read(found, resource) : instructions(found)
+      end
+
+      private
+
+      def instructions(skill)
+        folder = if @code_execution.call
+                   mount = self.class.mount_path(skill)
+                   "Its folder is at #{mount}/ in run_code's working directory, read-only. Paths in these " \
+                     "instructions are relative to it, so prefix them with #{mount}/. Run its scripts with " \
+                     'run_code from the working directory, and write output files to the working directory.'
+                 else
+                   'Paths in these instructions are relative to the skill folder. This conversation cannot run ' \
+                     "code, so the skill's scripts cannot run: follow the rest of the instructions, and say so " \
+                     'when a step needs a script.'
+                 end
+        "# Skill: #{skill.name}\n\n#{folder}\n\n#{skill.instructions.strip}"
+      end
+
+      def read(skill, file)
+        path = skill.resolve_file(file)
+        return { error: "#{file} is a folder holding: #{folder_entries(path)}" } if File.directory?(path)
+        return { error: "#{file} is larger than #{MAX_FILE_SIZE} bytes. #{use_from_code(skill, file)}" } if
+          File.size(path) > MAX_FILE_SIZE
+
+        content = File.binread(path).force_encoding(Encoding::UTF_8)
+        return { error: "#{file} is not a text file. #{use_from_code(skill, file)}" } unless text?(content)
+
+        content
+      rescue ArgumentError => e
+        { error: e.message }
+      rescue SystemCallError
+        { error: "The #{skill.name} skill has no file #{file}" }
+      end
+
+      def folder_entries(path)
+        Dir.children(path).sort.map { |entry| File.directory?(File.join(path, entry)) ? "#{entry}/" : entry }.join(', ')
+      end
+
+      def text?(content)
+        content.valid_encoding? && !content.include?("\0")
+      end
+
+      def use_from_code(skill, file)
+        return 'This conversation cannot run code to use it.' unless @code_execution.call
+
+        "Use it from run_code at #{self.class.mount_path(skill)}/#{file}."
+      end
+
+      def scripts_note
+        if @code_execution.call
+          'Each skill folder is mounted read-only in every run_code working directory at skills/<name>/, ' \
+            'so run_code can run its scripts, such as python skills/<name>/scripts/example.py.'
+        else
+          'This conversation cannot run code, so skill scripts cannot run. Follow the rest of their instructions.'
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/skill.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'yaml'
+
+module RubyLLM
+  # A Skill is a folder of instructions, scripts, and reference files in the
+  # open {Agent Skills}[https://agentskills.io/specification] format. Its
+  # +SKILL.md+ starts with YAML front matter naming and describing the
+  # skill, followed by the instructions in Markdown.
+  #
+  # Chat#with_skills gives skills to a chat. The model sees each skill's
+  # name and description, and loads the instructions and files of the ones
+  # a task needs.
+  #
+  #   skill = RubyLLM::Skill.find(:invoices)
+  #   skill.name        # => "invoices"
+  #   skill.description # => "Creates invoices as PDFs. Use when ..."
+  #   skill.path        # => #<Pathname:/app/app/skills/invoices>
+  class Skill
+    include Support::Inspectable
+
+    # The file every skill folder holds.
+    FILE = 'SKILL.md'
+
+    # Characters a name may have at most.
+    MAX_NAME = 64
+
+    # Characters a description may have at most.
+    MAX_DESCRIPTION = 1024
+
+    # Characters the compatibility field may have at most.
+    MAX_COMPATIBILITY = 500
+
+    FRONT_MATTER = /\A---[ \t]*\r?\n(.*?)^---[ \t]*(?:\r?\n|\z)/m
+    NAME_FORMAT = /\A[[:alnum:]]+(?:-[[:alnum:]]+)*\z/
+    private_constant :FRONT_MATTER, :NAME_FORMAT
+
+    # The skill's name, matching its folder name.
+    attr_reader :name
+
+    # What the skill does and when to use it.
+    attr_reader :description
+
+    # The license the front matter names, or +nil+.
+    attr_reader :license
+
+    # The environment requirements the front matter states, or +nil+.
+    attr_reader :compatibility
+
+    # The tools the front matter pre-approves, as an Array of Strings.
+    # RubyLLM reads the field but does not act on it.
+    attr_reader :allowed_tools
+
+    # The front matter's +metadata+, a Hash of Strings.
+    attr_reader :metadata
+
+    # The skill folder, as an absolute Pathname.
+    attr_reader :path
+
+    # The Markdown instructions that follow the front matter.
+    attr_reader :instructions
+
+    class << self
+      # Returns the ordered skill directories. Append engine directories
+      # with +<<+:
+      #
+      #   initializer "my_engine.skills", before: "ruby_llm.skills" do
+      #     RubyLLM::Skill.roots << MyEngine::Engine.root.join("app/skills")
+      #   end
+      #
+      def roots
+        @roots ||= Prompt::Roots.new { root }
+      end
+
+      def root # :nodoc:
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          Rails.root.join('app/skills')
+        else
+          Pathname.new(Dir.pwd).join('app/skills')
+        end
+      end
+
+      # Returns every skill directly under the skill roots. A skill in an
+      # earlier root hides one with the same folder name in a later root.
+      # Raises InvalidSkillError when a skill's +SKILL.md+ is invalid.
+      def all
+        folders = roots.flat_map { |root| skill_folders(Pathname.new(root)) }
+        folders.uniq(&:basename).map { |folder| new(folder) }
+      end
+
+      # Returns the skill in the folder called +name+ under the first skill
+      # root that has one. Underscores in a Symbol stand for hyphens, so
+      # <tt>:pdf_processing</tt> finds +pdf-processing+. Raises
+      # SkillNotFoundError when no root has it.
+      #
+      #   RubyLLM::Skill.find(:invoices)
+      #
+      def find(name)
+        folder = name.is_a?(Symbol) ? name.to_s.tr('_', '-') : name.to_s
+        found = (roots.map { |root| Pathname.new(root).join(folder) } if folder.match?(NAME_FORMAT))
+                &.find { |path| path.join(FILE).file? }
+        raise SkillNotFoundError, "No skill named #{folder} in #{roots.to_a.join(', ')}" unless found
+
+        new(found)
+      end
+
+      # Returns +true+, +false+, or the skill names and paths in
+      # +selection+, the arguments of Chat#with_skills. Raises
+      # ArgumentError for +nil+, and for +true+ or +false+ with names.
+      def selection(selection) # :nodoc:
+        raise ArgumentError, 'skills cannot be nil; pass false to remove them' if selection.include?(nil)
+        return true if selection.empty? || selection == [true]
+        return false if selection == [false]
+        raise ArgumentError, 'skills true and false take no skill names' if selection.intersect?([true, false])
+
+        selection.flatten.freeze
+      end
+
+      # Returns the skills +selection+ names: Symbols are folders under the
+      # skill roots, Strings and Pathnames are skill folders, and +true+ is
+      # every skill under the roots.
+      def resolve(selection) # :nodoc:
+        case selection
+        when true then all
+        when false then []
+        else selection.map { |entry| skill(entry) }
+        end
+      end
+
+      # Returns +current+ with +added+, refusing two skills with one name.
+      def merge(current, added) # :nodoc:
+        added.each_with_object(current.dup) do |skill, skills|
+          existing = skills.find { |other| other.name == skill.name }
+          next skills << skill unless existing
+          next if existing.path == skill.path
+
+          raise ArgumentError, "Two skills are named #{skill.name}: #{existing.path} and #{skill.path}"
+        end
+      end
+
+      private
+
+      def skill(entry)
+        case entry
+        when Skill then entry
+        when Symbol then find(entry)
+        when String, Pathname then new(entry)
+        else raise ArgumentError, "skills are Symbols, paths, or RubyLLM::Skill objects, got #{entry.inspect}"
+        end
+      end
+
+      def skill_folders(root)
+        return [] unless root.directory?
+
+        root.children.select { |child| child.join(FILE).file? }.sort
+      end
+    end
+
+    # Reads the skill in the folder at +path+. Raises SkillNotFoundError
+    # when the folder has no +SKILL.md+, and InvalidSkillError when its
+    # front matter breaks the Agent Skills specification. Front matter keys
+    # the specification does not define are ignored.
+    #
+    #   RubyLLM::Skill.new("vendor/skills/pdf")
+    #
+    def initialize(path)
+      @path = Pathname.new(File.realpath(path))
+      file = @path.join(FILE)
+      raise SkillNotFoundError, "#{file} not found" unless file.file?
+
+      content = file.read(encoding: 'UTF-8')
+      invalid('must be valid UTF-8') unless content.valid_encoding?
+
+      front_matter, @instructions = parse(content)
+      assign(front_matter)
+    rescue Errno::ENOENT, Errno::ENOTDIR
+      raise SkillNotFoundError, "No skill folder at #{path}"
+    end
+
+    # Returns the absolute path of the file at +relative+ inside the skill
+    # folder. Raises ArgumentError when +relative+ leaves the folder, even
+    # through a symbolic link, and Errno::ENOENT when nothing is there.
+    def resolve_file(relative) # :nodoc:
+      parts = relative.to_s.tr('\\', '/').split('/').reject { |part| part.empty? || part == '.' }
+      if relative.to_s.start_with?('/', '\\') || relative.to_s.match?(/\A[A-Za-z]:/) || parts.include?('..')
+        raise ArgumentError, "#{relative} is not a path inside the #{name} skill"
+      end
+
+      resolved = File.realpath(path.join(*parts))
+      inside = resolved == path.to_s || resolved.start_with?(File.join(path.to_s, ''))
+      raise ArgumentError, "#{relative} is not a path inside the #{name} skill" unless inside
+
+      resolved
+    end
+
+    def inspect_attributes # :nodoc:
+      { name:, description:, path: path.to_s }
+    end
+
+    private
+
+    def parse(content)
+      content = content.delete_prefix("\u{FEFF}")
+      match = FRONT_MATTER.match(content)
+      invalid('must start with YAML front matter between --- lines') unless match
+
+      front_matter = YAML.safe_load(match[1], permitted_classes: [Date, Time])
+      invalid('front matter must be a YAML mapping') unless front_matter.is_a?(Hash)
+      [front_matter.transform_keys(&:to_s), match.post_match]
+    rescue Psych::Exception => e
+      invalid("front matter is not valid YAML: #{e.message}")
+    end
+
+    def assign(front_matter)
+      @name = validated_name(front_matter['name'])
+      @description = required_text(front_matter, 'description', MAX_DESCRIPTION)
+      @license = optional_text(front_matter, 'license')
+      @compatibility = optional_text(front_matter, 'compatibility', MAX_COMPATIBILITY)
+      @allowed_tools = optional_text(front_matter, 'allowed-tools').to_s.split.freeze
+      @metadata = validated_metadata(front_matter['metadata'])
+    end
+
+    def validated_name(value)
+      name = required_text({ 'name' => value }, 'name', MAX_NAME).unicode_normalize(:nfkc)
+      unless name == name.downcase && name.match?(NAME_FORMAT)
+        invalid("name #{name.inspect} must be lowercase letters, digits, and single hyphens between them")
+      end
+      folder = path.basename.to_s.dup.force_encoding(Encoding::UTF_8).scrub.unicode_normalize(:nfkc)
+      invalid("name #{name.inspect} must match its folder name, #{folder}") unless name == folder
+
+      name
+    end
+
+    def required_text(front_matter, key, limit)
+      value = front_matter[key]
+      invalid("needs a #{key}") if value.nil? || (value.is_a?(String) && value.strip.empty?)
+
+      optional_text(front_matter, key, limit)
+    end
+
+    def optional_text(front_matter, key, limit = nil)
+      value = front_matter[key]
+      return if value.nil?
+
+      invalid("#{key} must be a string") unless value.is_a?(String)
+      invalid("#{key} must not be empty") if value.strip.empty?
+      invalid("#{key} must be at most #{limit} characters") if limit && value.length > limit
+      value.strip
+    end
+
+    def validated_metadata(value)
+      return {}.freeze if value.nil?
+
+      invalid('metadata must be a mapping of strings') unless value.is_a?(Hash)
+      value.to_h { |key, entry| [key.to_s, entry.to_s] }.freeze
+    end
+
+    def invalid(reason)
+      raise InvalidSkillError, "#{path.join(FILE)} #{reason}"
+    end
+  end
+end

data/lib/ruby_llm/speech.rb

@@ -9,7 +9,9 @@ module RubyLLM
   #
   class Speech
     include Support::Inspectable
+    include Files::Saving
     include Accounting::Usage::Result
+    include Accounting::Usage::ModelInfo
 
     # Maps audio format names to their MIME types.
     MIME_TYPES = {
@@ -38,7 +40,7 @@ module RubyLLM
     attr_reader :mime_type
 
     def initialize(data:, model:, voice: nil, format: 'mp3', mime_type: nil, # :nodoc:
-                   input_tokens: nil, output_tokens: nil)
+                   input_tokens: nil, output_tokens: nil, characters: nil)
       @data = data
       @model = model
       @voice = voice
@@ -46,6 +48,7 @@ module RubyLLM
       @mime_type = mime_type || MIME_TYPES.fetch(@format, "audio/#{@format}")
       @input_tokens = input_tokens
       @output_tokens = output_tokens
+      @characters = characters
     end
 
     # Generates speech for +input+ and returns a Speech holding the audio.
@@ -55,7 +58,7 @@ module RubyLLM
     # provider's request vocabulary, such as +instructions:+ and +speed:+
     # for OpenAI, and merges them into the request as-is.
     # +owner:+ attributes the usage to a record, such as a user, and wins
-    # over RubyLLM.with_usage_owner.
+    # over RubyLLM.with_owner.
     #
     #   speech = RubyLLM.speak "Hello, welcome to RubyLLM!"
     #   speech.save "welcome.mp3"
@@ -86,42 +89,28 @@ module RubyLLM
                    metadata: nil,
                    owner: nil,
                    &block)
-      config = context&.config || RubyLLM.config
-      model ||= config.default_speech_model
-      model, provider_instance = Models.resolve(model, provider: provider, assume_model_exists: assume_model_exists,
-                                                       config: config)
-      empty_tokens = Tokens.new
-
-      payload = {
-        provider: provider_instance.slug,
-        provider_class: provider_instance.name,
-        model: model.id,
-        model_info: model,
-        input: input,
-        voice: voice,
-        format: format,
-        provider_options: provider_options,
-        metadata: metadata,
-        streaming: !block.nil?,
-        tokens: empty_tokens,
-        cost: Cost.new(tokens: empty_tokens, model:, category: :audio_tokens)
-      }
-
-      RubyLLM.instrument('speech.ruby_llm', payload, config: config) do |event|
-        result = Accounting::Usage.owned_by(owner) do
-          provider_instance.speak(input, model:, voice:, format:, provider_options:, &block)
-        end
-        event[:result] = result
-        event[:response_model] = result.model
-        event[:voice] = result.voice
-        event[:format] = result.format
-        event[:audio_bytes] = result.to_blob.bytesize
-        event[:tokens] = result.tokens
-        event[:cost] = result.cost
-        result
+      Accounting::Operation.new(
+        'speech', model, default: :default_speech_model, category: :audio_tokens, provider:, assume_model_exists:,
+                         context:, owner:,
+                         details: lambda { |event, result|
+                           event[:voice] = result.voice
+                           event[:format] = result.format
+                           event[:audio_bytes] = result.to_blob.bytesize
+                         }
+      ).run(input:, voice:, format:, provider_options:, metadata:, streaming: !block.nil?) do |provider_instance, model|
+        provider_instance.speak(input, model:, voice:, format:, provider_options:, &block)
       end
     end
 
+    ##
+    # :method: save
+    # :call-seq:
+    #   save(path)
+    #
+    # Writes the audio to +path+ in binary mode and returns +path+.
+    #
+    #   speech.save "welcome.mp3"
+
     # Returns the raw audio bytes. Alias for #data, mirroring Image#to_blob.
     def to_blob
       data
@@ -132,7 +121,7 @@ module RubyLLM
     def tokens
       return ruby_llm_usage_tokens unless ruby_llm_usage_entries.empty?
 
-      Tokens.new(input: @input_tokens, output: @output_tokens)
+      Tokens.new(input: @input_tokens, output: @output_tokens, characters: @characters)
     end
 
     # Returns the speech cost across every provider attempt.
@@ -142,23 +131,6 @@ module RubyLLM
       Cost.new(tokens:, model: model_info, category: :audio_tokens)
     end
 
-    attr_writer :model_info # :nodoc:
-
-    def model_info # :nodoc:
-      @model_info ||= RubyLLM.models.find(model)
-    rescue ModelNotFoundError
-      nil
-    end
-
-    # Writes the audio to +path+ in binary mode and returns +path+.
-    #
-    #   speech.save "welcome.mp3"
-    #
-    def save(path)
-      File.binwrite(File.expand_path(path), to_blob)
-      path
-    end
-
     def inspect_attributes # :nodoc:
       { model: model, voice: voice, format: format, data: data && "#{data.bytesize} bytes" }
     end

data/lib/ruby_llm/stored_file.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # A file in a FileStore: its path, size, content type, and a digest of
+  # its content. FileStore#list and FileStore#find return them, and
+  # Chat#after_file_write callbacks receive each one the conversation
+  # writes.
+  #
+  #   chat.file_store.list
+  #   # => [#<RubyLLM::StoredFile path: "report.pdf", byte_size: 2201344, content_type: "application/pdf">]
+  #
+  class StoredFile
+    include Support::Inspectable
+
+    # The path of the file inside its store, relative and with forward
+    # slashes, such as <tt>"reports/q3.pdf"</tt>.
+    attr_reader :path
+
+    # The size of the file in bytes.
+    attr_reader :byte_size
+
+    # The MIME type of the file, such as <tt>"application/pdf"</tt>.
+    attr_reader :content_type
+
+    # A digest of the file's content that changes whenever the content
+    # does, or +nil+ when the store does not know one without reading the
+    # file. Stores in the box use SHA-256 in hex.
+    attr_reader :digest
+
+    # When the file was last written, or +nil+ when the store does not say.
+    attr_reader :updated_at
+
+    # Who wrote the file, for stores that keep one, or +nil+. RubyLLM
+    # stores it and hands it back without interpreting it.
+    attr_reader :owner
+
+    def initialize(path:, byte_size:, content_type:, digest: nil, updated_at: nil, owner: nil) # :nodoc:
+      @path = path
+      @byte_size = byte_size
+      @content_type = content_type
+      @digest = digest
+      @updated_at = updated_at
+      @owner = owner
+    end
+
+    # Returns the last part of #path.
+    #
+    #   file.path     # => "reports/q3.pdf"
+    #   file.filename # => "q3.pdf"
+    #
+    def filename
+      File.basename(path)
+    end
+
+    # Returns whether the content is text, like source code, CSV, or
+    # Markdown, judged by its content type.
+    def text?
+      Files::MimeType.text?(content_type)
+    end
+
+    # Returns the file's size for people and models to read, such as
+    # <tt>"2.1 MB"</tt>.
+    def human_size
+      units = %w[bytes KB MB GB TB]
+      size = byte_size.to_f
+      exponent = size.zero? ? 0 : [(Math.log(size) / Math.log(1024)).floor, units.size - 1].min
+      return "#{byte_size} #{byte_size == 1 ? 'byte' : 'bytes'}" if exponent.zero?
+
+      "#{(size / (1024**exponent)).round(1)} #{units[exponent]}"
+    end
+
+    # Returns whether +other+ is a StoredFile with the same path, size,
+    # content type, and digest.
+    def ==(other)
+      other.is_a?(StoredFile) && other.to_h.except(:updated_at, :owner) == to_h.except(:updated_at, :owner)
+    end
+    alias eql? ==
+
+    def hash # :nodoc:
+      to_h.except(:updated_at, :owner).hash
+    end
+
+    # Returns the attributes as a Hash.
+    def to_h
+      { path:, byte_size:, content_type:, digest:, updated_at:, owner: }
+    end
+
+    private
+
+    def inspect_attributes
+      { path:, byte_size:, content_type: }
+    end
+  end
+end

data/lib/ruby_llm/support/cancellation.rb

@@ -13,15 +13,15 @@ module RubyLLM
       module_function
 
       def watch(checkpoint)
-        previous = Thread.current[KEY]
-        Thread.current[KEY] = checkpoint
+        previous = Fiber[KEY]
+        Fiber[KEY] = checkpoint
         yield
       ensure
-        Thread.current[KEY] = previous
+        Fiber[KEY] = previous
       end
 
       def check
-        Thread.current[KEY]&.call
+        Fiber[KEY]&.call
       end
 
       def pause(seconds)

data/lib/ruby_llm/support/deprecated_enumerable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Support
+    # Keeps chats, agents, and <tt>acts_as_chat</tt> records Enumerable over
+    # their messages through RubyLLM 2.x. Their +each+ is deprecated, and
+    # the Enumerable methods built on it with it: iterate +messages+
+    # instead. RubyLLM 3.0 removes them.
+    module DeprecatedEnumerable # :nodoc:
+      include Enumerable
+    end
+  end
+end

data/lib/ruby_llm/support/deprecated_job_predicates.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Support
+    module DeprecatedJobPredicates # :nodoc:
+      def done?
+        warn_about_predicate(:done?, :complete?)
+        complete?
+      end
+
+      def completed?
+        warn_about_predicate(:completed?, :succeeded?)
+        succeeded?
+      end
+
+      private
+
+      def warn_about_predicate(name, replacement)
+        RubyLLM.deprecator.deprecate("#{self.class}##{name}", replacement: "#{self.class}##{replacement}",
+                                                              removal: '3.0')
+      end
+    end
+  end
+end

data/lib/ruby_llm/support/inspectable.rb

@@ -17,7 +17,7 @@ module RubyLLM
         attributes = inspect_attributes
                      .reject { |_, value| value.nil? || (value.respond_to?(:empty?) && value.empty?) }
                      .map { |name, value| "#{name}: #{format_for_inspect(value)}" }
-        class_name = self.class.ancestors.find(&:name).name
+        class_name = self.class.ancestors.grep(Class).find(&:name).name
         return "#<#{class_name}>" if attributes.empty?
 
         "#<#{class_name} #{attributes.join(', ')}>"