ruby_llm-agent-evaluations 0.3.0 → 0.3.1

data/lib/ruby_llm/evaluations/a2ui/catalogs.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "json_schemer"
+require_relative "../data"
+
+module RubyLLM
+  module Evaluations
+    module A2UI
+      class Catalogs
+        STANDARD_ID = "https://a2ui.org/specification/v0_8/standard_catalog_definition.json".freeze
+        ASSETS = File.expand_path("assets/v0_8", __dir__).freeze
+        OFFLINE_RESOLVER = proc { |uri| raise ArgumentError, "external or unresolved schema reference: #{uri}" }.freeze
+
+        attr_reader :definitions
+
+        def initialize(custom_catalogs = {})
+          raise ArgumentError, "catalogs must be a Hash" unless custom_catalogs.is_a?(Hash)
+          standard = load_definition(File.join(ASSETS, "standard_catalog_definition.json"))
+          standard["catalogId"] = STANDARD_ID
+          @definitions = { STANDARD_ID => standard }
+          custom_catalogs.each do |id, source|
+            raise ArgumentError, "catalog ID must be a string or symbol" unless id.is_a?(String) || id.is_a?(Symbol)
+            id = id.to_s
+            raise ArgumentError, "cannot override standard catalog" if id == STANDARD_ID || id == "standard"
+            raise ArgumentError, "duplicate catalog ID #{id.inspect}" if @definitions.key?(id)
+            definition = load_definition(source)
+            if definition.key?("catalogId") && definition["catalogId"] != id
+              raise ArgumentError, "catalog #{id.inspect}: catalogId must match its configured ID"
+            end
+            definition["catalogId"] = id
+            @definitions[id] = definition
+          end
+          @components = {}
+          @styles = {}
+          @definitions.each { |id, definition| configure(id, definition) }
+          @message_schema = compile(JSON.parse(File.read(File.join(ASSETS, "server_to_client.json"))), "message schema")
+          freeze_tree(@definitions)
+        end
+
+        def known?(id)
+          @definitions.key?(id)
+        end
+
+        def message_errors(message)
+          errors(@message_schema, message, "message")
+        end
+
+        def component_errors(catalog_id, type, props)
+          id = catalog_id
+          return ["unknown catalog #{catalog_id.inspect}"] unless known?(id)
+          schema = @components.fetch(id)[type.to_s]
+          return ["catalog #{id.inspect}: unknown component type #{type.inspect}"] unless schema
+          errors(schema, props, "component #{type.inspect}")
+        end
+
+        def style_errors(catalog_id, styles)
+          id = catalog_id
+          return ["unknown catalog #{catalog_id.inspect}"] unless known?(id)
+          return ["styles must be an object"] unless styles.is_a?(Hash)
+          styles.flat_map do |name, value|
+            schema = @styles.fetch(id)[name.to_s]
+            schema ? errors(schema, value, "style #{name.inspect}") : ["catalog #{id.inspect}: unknown style #{name.inspect}"]
+          end
+        end
+
+        private
+
+        def load_definition(source)
+          value = case source
+                  when Hash then Data.snapshot(source)
+                  when String, Pathname then JSON.parse(File.read(source.to_s))
+                  else raise ArgumentError, "catalog definition must be a Hash or local JSON file path"
+                  end
+          raise ArgumentError, "catalog definition must be an object" unless value.is_a?(Hash)
+          value
+        rescue JSON::ParserError, SystemCallError => error
+          raise ArgumentError, "invalid catalog definition: #{error.message}"
+        end
+
+        def configure(id, definition)
+          compile(definition.slice("$schema", "$defs", "definitions"), "catalog #{id.inspect}")
+          %w[components styles].each do |section|
+            entries = definition[section]
+            raise ArgumentError, "catalog #{id.inspect}: #{section} must be an object" unless entries.is_a?(Hash)
+            compiled = entries.to_h do |name, schema|
+              # Catalog-level definitions are shared; components can override them locally.
+              schema = definition.slice("$schema", "$defs", "definitions").merge(schema) if schema.is_a?(Hash)
+              [name, compile(schema, "catalog #{id.inspect} #{section}/#{name}")]
+            end
+            (section == "components" ? @components : @styles)[id] = compiled
+          end
+        end
+
+        def compile(schema, label)
+          unless schema.is_a?(Hash) || schema == true || schema == false
+            raise ArgumentError, "#{label}: schema must be an object or boolean"
+          end
+          compiled = JSONSchemer.schema(schema, ref_resolver: OFFLINE_RESOLVER)
+          failures = compiled.validate_schema.to_a
+          unless failures.empty?
+            raise ArgumentError, "#{label}: malformed schema: #{failures.map { |error| error['error'] }.join('; ')}"
+          end
+          # Resolve real schema references eagerly; annotation/default data is not schema.
+          compiled.bundle
+          compiled
+        rescue ArgumentError
+          raise
+        rescue StandardError => error
+          raise ArgumentError, "#{label}: invalid schema: #{error.message}"
+        end
+
+        def errors(schema, value, label)
+          schema.validate(Data.json_value(value)).map do |error|
+            pointer = error.fetch("data_pointer")
+            "#{label} at #{pointer.empty? ? '/' : pointer}: #{error['error'] || error['type']}"
+          end
+        rescue ArgumentError => error
+          ["#{label}: #{error.message}"]
+        end
+
+        def freeze_tree(value)
+          case value
+          when Hash
+            value.each { |key, item| key.freeze; freeze_tree(item) }
+          when Array
+            value.each { |item| freeze_tree(item) }
+          end
+          value.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/evaluations/a2ui/document.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubyLLM
+  module Evaluations
+    module A2UI
+      # Replays protocol messages without rendering or resolving remote catalogs.
+      class Document
+        ACTIONS = %w[surfaceUpdate beginRendering dataModelUpdate deleteSurface].freeze
+        VALUES = %w[valueString valueNumber valueBoolean valueMap].freeze
+        private_constant :ACTIONS, :VALUES
+
+        attr_reader :errors, :surfaces
+
+        def initialize(catalogs)
+          @catalogs = catalogs
+          @errors = []
+          @surfaces = {}
+        end
+
+        def read(response_components)
+          @errors = []
+          @surfaces = {}
+          @records = []
+          @locations = {}
+          @component_locations = {}
+          @message_index = 0
+          unless response_components.is_a?(Array) && !response_components.empty?
+            errors << "A2UI requires a nonempty response component envelope array"
+            return self
+          end
+          response_components.each_with_index do |envelope, index|
+            unless envelope.is_a?(Hash) && envelope.key?("payload")
+              errors << "Envelope #{index + 1}: expected an object containing payload"
+              next
+            end
+            messages(envelope["payload"], "Envelope #{index + 1}").each do |message|
+              @message_index += 1
+              replay(message)
+            end
+          end
+          validate_records
+          validate_surfaces
+          unless surfaces.values.any? { |surface| surface["rendered"] }
+            errors << "A2UI requires at least one live rendered surface"
+          end
+          self
+        end
+
+        private
+
+        def messages(payload, location)
+          if payload.is_a?(String)
+            if payload.strip.empty?
+              errors << "#{location}: payload is empty"
+              return []
+            end
+            begin
+              payload = JSON.parse(payload)
+            rescue JSON::ParserError => error
+              lines = payload.lines.reject { |line| line.strip.empty? }
+              if lines.size < 2
+                errors << "#{location}: malformed JSON: #{error.message}"
+                return []
+              end
+              return lines.each_with_index.flat_map do |line, index|
+                begin
+                  messages(JSON.parse(line), "#{location}, JSONL line #{index + 1}")
+                rescue JSON::ParserError => line_error
+                  errors << "#{location}, JSONL line #{index + 1}: malformed JSON: #{line_error.message}"
+                  []
+                end
+              end
+            end
+          end
+          case payload
+          when Hash then [payload]
+          when Array
+            errors << "#{location}: message array is empty" if payload.empty?
+            payload
+          else
+            errors << "#{location}: payload must be a message object, message array, or JSON/JSONL string"
+            []
+          end
+        end
+
+        def replay(message)
+          location = "Message #{@message_index}"
+          unless message.is_a?(Hash)
+            errors << "#{location}: message must be an object"
+            return
+          end
+          actions = ACTIONS.select { |action| message.key?(action) }
+          if actions.size != 1
+            errors << "#{location}: message must contain exactly one action (#{ACTIONS.join(', ')})"
+          end
+          schema_errors = @catalogs.message_errors(message)
+          action = actions.first
+          body = message[action]
+          if body.is_a?(Hash)
+            location += ", surface #{body['surfaceId'].inspect}, /#{action}"
+          end
+          schema_errors.each { |error| errors << "#{location}: #{error}" }
+          return unless actions.size == 1 && schema_errors.empty?
+
+          id = body["surfaceId"]
+          if action == "deleteSurface"
+            surfaces.delete(id)
+            return
+          end
+          surface = surfaces[id] ||= {
+            "root" => nil, "catalog" => Catalogs::STANDARD_ID,
+            "components" => {}, "styles" => {}, "rendered" => false
+          }
+          @locations[surface.object_id] = location
+          case action
+          when "surfaceUpdate"
+            seen = {}
+            body["components"].each_with_index do |component, index|
+              component_id = component["id"]
+              path = "#{location}/components/#{index}, component #{component_id.inspect}"
+              errors << "#{path}: duplicate component ID within this update" if seen[component_id]
+              seen[component_id] = true
+              wrapper = component["component"]
+              unless wrapper.size == 1
+                errors << "#{path}/component: expected exactly one component type"
+                next
+              end
+              type, props = wrapper.first
+              record = { "type" => type, "props" => copy(props) }
+              surface["components"][component_id] = record
+              (@component_locations[surface.object_id] ||= {})[component_id] = path
+              catalog = surface["rendered"] ? surface["catalog"] : surface
+              @records << [catalog, :component, record, "#{path}/component/#{type}"]
+            end
+          when "beginRendering"
+            catalog = copy(body.fetch("catalogId", Catalogs::STANDARD_ID))
+            if surface["rendered"] && surface["catalog"] != catalog
+              surface["components"].each do |component_id, component|
+                path = "#{location}, component #{component_id.inspect}/component/#{component['type']}"
+                @records << [catalog, :component, component, path]
+              end
+            end
+            @records.each { |record| record[0] = catalog if record[0].equal?(surface) }
+            surface["root"] = copy(body["root"])
+            surface["catalog"] = catalog
+            surface["styles"] = copy(body.fetch("styles", {}))
+            surface["rendered"] = true
+            @records << [catalog, :styles, surface["styles"], "#{location}/styles"]
+            unless @catalogs.known?(surface["catalog"])
+              errors << "#{location}/catalogId: unknown catalog #{surface['catalog'].inspect} (only registered offline catalogs are allowed)"
+            end
+          when "dataModelUpdate"
+            validate_entries(body["contents"], "#{location}/contents")
+          end
+        end
+
+        def validate_entries(entries, location)
+          entries.each_with_index do |entry, index|
+            path = "#{location}/#{index}"
+            typed = VALUES.select { |key| entry.key?(key) }
+            errors << "#{path}: data entry must contain exactly one typed value" unless typed.size == 1
+            validate_entries(entry["valueMap"], "#{path}/valueMap") if entry["valueMap"].is_a?(Array)
+          end
+        end
+
+        # Components may precede beginRendering, so catalog checks wait until replay
+        # has selected the surface's catalog. Keep overwritten/deleted evidence too.
+        def validate_records
+          @records.each do |selection, kind, value, location|
+            catalog = selection.is_a?(Hash) ? selection["catalog"] : selection
+            next unless @catalogs.known?(catalog)
+            failures = if kind == :component
+              @catalogs.component_errors(catalog, value["type"], value["props"])
+            else
+              @catalogs.style_errors(catalog, value)
+            end
+            failures.each { |error| errors << "#{location}: #{error}" }
+            if kind == :component && catalog == Catalogs::STANDARD_ID
+              references(value, location)
+            end
+          end
+        end
+
+        def validate_surfaces
+          surfaces.each do |id, surface|
+            location = "#{@locations[surface.object_id]}, surface #{id.inspect}"
+            if surface["rendered"] && !surface["components"].key?(surface["root"])
+              errors << "#{location}/root: rendered root #{surface['root'].inspect} does not exist"
+            end
+            next unless surface["catalog"] == Catalogs::STANDARD_ID
+            graph = {}
+            surface["components"].each do |component_id, component|
+              path = @component_locations.fetch(surface.object_id, {}).fetch(component_id, location)
+              graph[component_id] = references(component, path, report: false)
+              graph[component_id].each do |target, reference_path|
+                unless surface["components"].key?(target)
+                  errors << "#{reference_path}: dangling component reference #{target.inspect}"
+                end
+              end
+            end
+            validate_cycles(graph, location)
+          end
+        end
+
+        def references(component, location, report: true)
+          props = component["props"]
+          return [] unless props.is_a?(Hash)
+          refs = []
+          case component["type"]
+          when "Row", "Column", "List"
+            children = props["children"]
+            if children.is_a?(Hash)
+              alternatives = %w[explicitList template].select { |key| children.key?(key) }
+              if report && alternatives.size != 1
+                errors << "#{location}/children: expected exactly one of explicitList or template"
+              end
+              if children["explicitList"].is_a?(Array)
+                children["explicitList"].each_with_index { |id, index| refs << [id, "#{location}/children/explicitList/#{index}"] }
+              end
+              template = children["template"]
+              refs << [template["componentId"], "#{location}/children/template/componentId"] if template.is_a?(Hash) && template.key?("componentId")
+            end
+          when "Card", "Button"
+            refs << [props["child"], "#{location}/child"] if props.key?("child")
+          when "Modal"
+            %w[entryPointChild contentChild].each { |key| refs << [props[key], "#{location}/#{key}"] if props.key?(key) }
+          when "Tabs"
+            if props["tabItems"].is_a?(Array)
+              props["tabItems"].each_with_index do |tab, index|
+                refs << [tab["child"], "#{location}/tabItems/#{index}/child"] if tab.is_a?(Hash) && tab.key?("child")
+              end
+            end
+          end
+          refs
+        end
+
+        def validate_cycles(graph, location)
+          state = {}
+          graph.each_key do |start|
+            next if state[start]
+            stack = [[start, false]]
+            until stack.empty?
+              id, leaving = stack.pop
+              if leaving
+                state[id] = :done
+                next
+              end
+              next if state[id] == :done
+              state[id] = :visiting
+              stack << [id, true]
+              graph.fetch(id, []).reverse_each do |target, path|
+                if state[target] == :visiting
+                  errors << "#{path}: component reference cycle involving #{target.inspect}"
+                elsif graph.key?(target) && !state[target]
+                  stack << [target, false]
+                end
+              end
+            end
+          end
+        end
+
+        def copy(value)
+          case value
+          when Hash then value.to_h { |key, item| [key, copy(item)] }
+          when Array then value.map { |item| copy(item) }
+          when String then value.dup
+          else value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/evaluations/a2ui/evaluator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Evaluations
+    module A2UI
+      class Evaluator
+        attr_reader :definition
+
+        def initialize(version: "0.8", catalogs: {})
+          raise ArgumentError, "Supported A2UI version is 0.8" unless version == "0.8"
+          @catalogs = Catalogs.new(catalogs)
+          @definition = { "version" => version.dup.freeze, "catalogs" => @catalogs.definitions }.freeze
+          @check = Evaluators.response_components(protocol: "a2ui", version: version) do |components, context|
+            document = Document.new(@catalogs).read(components)
+            errors = document.errors
+            errors += Expectations.new(context.metadata, @catalogs).check(document) if errors.empty?
+            Assessment.new(score: errors.empty?, reason: errors.empty? ? "Valid A2UI 0.8 response" : errors.join("; "))
+          end
+        end
+
+        def validate_expectations!(metadata)
+          Expectations.new(metadata, @catalogs)
+        end
+
+        def call(output, context)
+          @check.call(output, context)
+        end
+      end
+    end
+
+    module Evaluators
+      def self.a2ui(version: "0.8", catalogs: {})
+        A2UI::Evaluator.new(version: version, catalogs: catalogs)
+      end
+    end
+  end
+end

data/lib/ruby_llm/evaluations/a2ui/expectations.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Evaluations
+    module A2UI
+      # Business assertions are question data, so changing them changes the suite fingerprint.
+      class Expectations
+        def initialize(metadata, catalogs)
+          value = metadata.key?(:a2ui) ? metadata[:a2ui] : metadata["a2ui"]
+          @surfaces = {}
+          return unless metadata.key?(:a2ui) || metadata.key?("a2ui")
+
+          value = Data.json_value(value)
+          fields!(value, %w[surfaces], "metadata.a2ui")
+          @surfaces = value.fetch("surfaces", {})
+          raise DefinitionError, "metadata.a2ui.surfaces must be a Hash" unless @surfaces.is_a?(Hash)
+          @surfaces.each do |id, surface|
+            label!(id, "surface ID")
+            fields!(surface, %w[catalog root components], "surface #{id}")
+            if surface.key?("catalog")
+              label!(surface["catalog"], "surface #{id} catalog")
+              unless catalogs.known?(catalog_id(surface["catalog"]))
+                raise DefinitionError, "Unknown expected A2UI catalog: #{surface['catalog']}"
+              end
+            end
+            label!(surface["root"], "surface #{id} root") if surface.key?("root")
+            components = surface.fetch("components", {})
+            raise DefinitionError, "surface #{id} components must be a Hash" unless components.is_a?(Hash)
+            components.each do |component_id, component|
+              label!(component_id, "component ID")
+              fields!(component, %w[type props], "surface #{id} component #{component_id}")
+              label!(component["type"], "component #{component_id} type") if component.key?("type")
+              if component.key?("props") && !component["props"].is_a?(Hash)
+                raise DefinitionError, "component #{component_id} props must be a Hash"
+              end
+            end
+          end
+        end
+
+        def check(document)
+          errors = []
+          @surfaces.each do |id, expected|
+            path = "surface #{id}"
+            actual = document.surfaces[id]
+            unless actual && actual["rendered"]
+              errors << "#{path}: expected a rendered surface"
+              next
+            end
+            compare(catalog_id(expected["catalog"]), actual["catalog"], "#{path} catalog", errors) if expected.key?("catalog")
+            compare(expected["root"], actual["root"], "#{path} root", errors) if expected.key?("root")
+            expected.fetch("components", {}).each do |component_id, component|
+              component_path = "#{path} component #{component_id}"
+              observed = actual.fetch("components")[component_id]
+              unless observed
+                errors << "#{component_path}: missing component"
+                next
+              end
+              compare(component["type"], observed["type"], "#{component_path} type", errors) if component.key?("type")
+              compare(component["props"], observed["props"], "#{component_path} props", errors) if component.key?("props")
+            end
+          end
+          errors
+        end
+
+        private
+
+        def compare(expected, actual, path, errors)
+          if expected.is_a?(Hash) && actual.is_a?(Hash)
+            expected.each do |key, value|
+              if actual.key?(key)
+                compare(value, actual[key], "#{path}.#{key}", errors)
+              else
+                errors << "#{path}.#{key}: missing property"
+              end
+            end
+          elsif expected != actual
+            errors << "#{path}: expected #{expected.inspect}, got #{actual.inspect}"
+          end
+        end
+
+        def catalog_id(value)
+          value == "standard" ? Catalogs::STANDARD_ID : value
+        end
+
+        def fields!(value, allowed, path)
+          raise DefinitionError, "#{path} must be a Hash" unless value.is_a?(Hash)
+          unknown = value.keys - allowed
+          raise DefinitionError, "#{path}: unknown assertions #{unknown.join(', ')}" unless unknown.empty?
+        end
+
+        def label!(value, label)
+          raise DefinitionError, "#{label} must be a nonempty String" unless value.is_a?(String) && !value.strip.empty?
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/evaluations/suite.rb

@@ -81,6 +81,7 @@ module RubyLLM
             custom = evaluators.find { |definition| definition.name == metric_name }
             callable = custom ? custom.callable : standard_metric(metric_name)
             next if judge.nil? && callable.is_a?(JudgeMetric)
+            callable.validate_expectations!(item.metadata) if callable.is_a?(A2UI::Evaluator)
             Evaluator.new(name: metric_name, callable: callable, threshold: threshold).freeze
           end.freeze
           Question.new(**item.to_h, minimum_scores: immutable_copy(minimum_scores),
@@ -98,6 +99,10 @@ module RubyLLM
                          data = data.merge(api_interactions: item.api_interactions.to_h) if item.api_interactions
                          skipped = item.minimum_scores.keys - item.evaluators.map(&:name)
                          data = data.merge(skipped_metrics: skipped) unless skipped.empty?
+                         ui = item.evaluators.filter_map do |evaluator|
+                           [evaluator.name, evaluator.callable.definition] if evaluator.callable.is_a?(A2UI::Evaluator)
+                         end.to_h
+                         data = data.merge(a2ui_evaluators: ui) unless ui.empty?
                          definition_value(data)
                        end }
         Digest::SHA256.hexdigest(JSON.generate(Data.canonical(definition)))
@@ -111,6 +116,8 @@ module RubyLLM
           Evaluators.public_send(name)
         when "action_group"
           Evaluators.action_group
+        when "a2ui"
+          @a2ui_evaluator ||= Evaluators.a2ui
         else
           raise DefinitionError, "unknown metric: #{name}; register it with evaluate"
         end

data/lib/ruby_llm/evaluations/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module Evaluations
-    VERSION = "0.3.0"
+    VERSION = "0.3.1"
   end
 end

data/lib/ruby_llm/evaluations.rb

@@ -8,6 +8,10 @@ require_relative "evaluations/response_component_capture"
 require_relative "evaluations/response_component_tool"
 require_relative "evaluations/judge_metric"
 require_relative "evaluations/evaluators"
+require_relative "evaluations/a2ui/catalogs"
+require_relative "evaluations/a2ui/document"
+require_relative "evaluations/a2ui/expectations"
+require_relative "evaluations/a2ui/evaluator"
 require_relative "evaluations/api_replay"
 require_relative "evaluations/suite"
 require_relative "evaluations/response"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-agent-evaluations
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - RubyLLM Evaluations contributors
 bindir: exe
 cert_chain: []
-date: 2026-10-12 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -29,6 +29,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
+- !ruby/object:Gem::Dependency
+  name: json_schemer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: webrick
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +103,14 @@ files:
 - examples/support_eval.rb
 - exe/ruby_llm-agent-evaluations
 - lib/ruby_llm/evaluations.rb
+- lib/ruby_llm/evaluations/a2ui/assets/LICENSE
+- lib/ruby_llm/evaluations/a2ui/assets/PROVENANCE.json
+- lib/ruby_llm/evaluations/a2ui/assets/v0_8/server_to_client.json
+- lib/ruby_llm/evaluations/a2ui/assets/v0_8/standard_catalog_definition.json
+- lib/ruby_llm/evaluations/a2ui/catalogs.rb
+- lib/ruby_llm/evaluations/a2ui/document.rb
+- lib/ruby_llm/evaluations/a2ui/evaluator.rb
+- lib/ruby_llm/evaluations/a2ui/expectations.rb
 - lib/ruby_llm/evaluations/action_group.rb
 - lib/ruby_llm/evaluations/actions.rb
 - lib/ruby_llm/evaluations/adapters.rb