ruby_llm-contract 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fead48c5516f8e0aa738d3ab1633ca2d07f7173aba6466a6d29e37634263b857
-  data.tar.gz: 4ae4c314cd6365c5f5de455f9dc5ddc0741abd26fa751804b22c5ffded0e6cb1
+  metadata.gz: 2532bf3e16d6e810c3caf8ac7d3d94e9ed43f87cdb9945c26ca33977d619ba39
+  data.tar.gz: f281f6b10532ef145821e60f9de352cc7bb2f07946ff146497ec537b28d430c5
 SHA512:
-  metadata.gz: 9b66df1e490e238fdacc84a728b874a008b80c8b44cdd882b444a84389bb77996ee6132efb6adaad79c91a04bee30eb7351241a4989ff1a4ed5df8d7a6cff619
-  data.tar.gz: a055fd3d06ee4fa9591fa2a6cfed6872142febd950fe3a455daa6e588f04e157a585701456f4815483ecc3accb803cf3bbcffa9308c6dfa5011c00f6a7143274
+  metadata.gz: c53ac500520e51a63134c7060a214944abb7839753ac22007d2034d3ab338eb0f20d6b8fd06c86904a3ecd5e026f16f83e9d83b58cd051a6ff35ce2b208e7334
+  data.tar.gz: 9ae24e6b2719f40a2045deb8f419fc3d3adf92bd98c51d9360d08db440d189997f2f0866a8ca6ae5eecc611226d5869c8c57c1321e32390a188063c7aec05c12

data/CHANGELOG.md

@@ -1,8 +1,30 @@
 # Changelog
 
+## 1.3.0 (2026-10-11)
+
+### Changed - may turn a green CI red
+
+- **A non-null value under `anyOf` / `oneOf` is now validated against the branches.**
+  0.10.3 taught the validator to accept `nil` through a null branch, but a non-null
+  value was never checked at all: the child node carried the composition wrapper,
+  which has no `type` or `properties`, so nothing ran. A nullable object block
+  (`any_of :block do object do ... end; null end`) missing a required field, with
+  a wrong-typed field or with an extra key came back `:ok`. Measured in an adopter:
+  a page-analysis block without `score` was `:ok` and became a 0/10 fail downstream.
+  `anyOf` now passes when at least one branch validates and `oneOf` when exactly one
+  does. When none does, the errors of the one branch whose type fits the value are
+  reported (`missing required field: block.score`); otherwise
+  `block: expected one of object, null, got String`. A `oneOf` value matching two
+  branches fails with `matches 2 oneOf branches, expected exactly 1`. Steps whose
+  model already returns schema-conforming output (OpenAI strict mode) are
+  unaffected; output that slipped through before now fails as `:validation_failed`.
+- **`type` given as an array is checked.** `type: ["string", "null"]` accepted any
+  value; it now accepts a value of any listed type and reports
+  `x: expected string or null, got Integer` otherwise. `"null"` is a known type.
+
 ## 1.2.0 (2026-10-10)
 
-Everything new is opt-in, except the temperature fix below.
+Everything new is opt-in. Two changes under "Changed" can affect existing steps: the temperature fix and `retry_on` rejecting conditions it cannot match.
 
 ### Added
 

data/lib/ruby_llm/contract/contract/schema_validator/node.rb

@@ -29,6 +29,22 @@ module RubyLLM
           Array(schema[:required]).map(&:to_s)
         end
 
+        def composition
+          SchemaValidator::COMPOSITION_KEYWORDS.each do |keyword|
+            branches = schema[keyword]
+            return [keyword, branches] if branches.is_a?(Array) && !branches.empty?
+          end
+          nil
+        end
+
+        def with_schema(branch_schema)
+          with(schema: branch_schema)
+        end
+
+        def label
+          path || "root"
+        end
+
         def items_schema
           schema[:items]
         end

data/lib/ruby_llm/contract/contract/schema_validator/type_rule.rb

@@ -9,12 +9,12 @@ module RubyLLM
         end
 
         def validate(node)
-          expected_type = node.expected_type
+          expected_types = Array(node.schema[:type]).map(&:to_s)
           value = node.value
-          return unless expected_type
-          return if type_valid?(expected_type, value)
+          return if expected_types.empty?
+          return if expected_types.any? { |type| type_valid?(type, value) }
 
-          @errors << "#{node.path}: expected #{expected_type}, got #{value.class}"
+          @errors << "#{node.path}: expected #{expected_types.join(" or ")}, got #{value.class}"
         end
 
         private

data/lib/ruby_llm/contract/contract/schema_validator.rb

@@ -25,8 +25,10 @@ module RubyLLM
         "number" => ->(value) { value.is_a?(Numeric) },
         "boolean" => ->(value) { value.is_a?(TrueClass) || value.is_a?(FalseClass) },
         "array" => ->(value) { value.is_a?(Array) },
-        "object" => ->(value) { value.is_a?(Hash) }
+        "object" => ->(value) { value.is_a?(Hash) },
+        "null" => lambda(&:nil?)
       }.freeze
+      COMPOSITION_KEYWORDS = %i[anyOf oneOf].freeze
 
       def self.validate(parsed_output, schema)
         new(parsed_output, schema).validate
@@ -59,11 +61,52 @@ module RubyLLM
       end
 
       def validate_node(node)
+        return validate_composition(node) if node.composition
+
         @scalar_rules.validate(node)
         @object_rules.validate(node) { |child| validate_node(child) } if node.hash? && node.object_schema?
         validate_array(node) if node.array?
       end
 
+      # anyOf passes when at least one branch validates, oneOf when exactly one
+      # does. When none does, the errors of the one branch whose type fits the
+      # value are the useful ones; otherwise the value matches no branch type.
+      def validate_composition(node)
+        keyword, branches = node.composition
+        branch_errors = branches.map { |branch| errors_for(node.with_schema(branch)) }
+        passing = branch_errors.count(&:empty?)
+        return if keyword == :anyOf ? passing.positive? : passing == 1
+
+        if passing > 1
+          @errors << "#{node.label}: matches #{passing} oneOf branches, expected exactly 1"
+        else
+          report_no_matching_branch(node, branches, branch_errors)
+        end
+      end
+
+      def report_no_matching_branch(node, branches, branch_errors)
+        fitting = branches.each_index.select { |i| branch_type_fits?(branches[i], node.value) }
+        return @errors.concat(branch_errors[fitting.first]) if fitting.size == 1
+
+        types = branches.flat_map { |branch| branch_types(branch) }.uniq
+        @errors << "#{node.label}: expected one of #{types.join(", ")}, got #{node.value.class}"
+      end
+
+      def errors_for(node)
+        before = @errors.size
+        validate_node(node)
+        @errors.slice!(before..)
+      end
+
+      def branch_type_fits?(branch, value)
+        branch_types(branch).any? { |type| TYPE_CHECKS.fetch(type, ->(_) { true }).call(value) }
+      end
+
+      def branch_types(branch)
+        types = Array(branch[:type]).map(&:to_s)
+        types.empty? && branch.key?(:properties) ? ["object"] : types
+      end
+
       def validate_array(node)
         items_schema = node.items_schema
         return unless items_schema.is_a?(Hash)

data/lib/ruby_llm/contract/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module Contract
-    VERSION = "1.2.0"
+    VERSION = "1.3.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-contract
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Justyna