ruby_llm-schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f2af8bd6f95696f6f8ab70e9d83637772bc1cdd3bf6fea283d2d7389a31a156e
+  data.tar.gz: ae39967ea90ec3a189eb0399bcc58da9d3da33d94093d98934bdda71485d70b0
+SHA512:
+  metadata.gz: 5d5903e14886b65431d92dfd511a61db51a824b03da19caf6fe062d1384ae12f4ec1a5004f2b1d2974ed1b32da8b91ca45243c5b299014b4a845828d4722506f
+  data.tar.gz: bb501057362585d42a11abfdc4de38a7743b8944699fcfd24e234655f478d6999c49c3d2659a7538e89d279a56f7dfea51e1577694f1941b8b97fbfa65758a44

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--color
+--format documentation 

data/.rspec_status

@@ -0,0 +1,55 @@
+example_id                                                | status | run_time        |
+--------------------------------------------------------- | ------ | --------------- |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:1:1] | passed | 0.0002 seconds  |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:1:2] | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:2:1] | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:2:2] | passed | 0.00027 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:3:1] | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:3:2] | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:4:1] | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:1:4:2] | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:2:1]   | passed | 0.00044 seconds |
+./spec/ruby_llm/schema_class_inheritance_spec.rb[1:3:1]   | passed | 0.00058 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:1:1]           | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:1:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:2:1]           | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:2:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:3:1]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:3:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:4:1]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:1:4:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:2:1]             | passed | 0.00005 seconds |
+./spec/ruby_llm/schema_factory_spec.rb[1:3:1]             | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:1:1]           | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:1:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:2:1]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:2:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:3:1]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:3:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:4:1]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:1:4:2]           | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:2:1]             | passed | 0.00005 seconds |
+./spec/ruby_llm/schema_helpers_spec.rb[1:3:1]             | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_spec.rb[1:1:1]                     | passed | 0.00018 seconds |
+./spec/ruby_llm/schema_spec.rb[1:1:2]                     | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_spec.rb[1:1:3]                     | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_spec.rb[1:1:4]                     | passed | 0.00002 seconds |
+./spec/ruby_llm/schema_spec.rb[1:1:5]                     | passed | 0.00002 seconds |
+./spec/ruby_llm/schema_spec.rb[1:1:6]                     | passed | 0.0006 seconds  |
+./spec/ruby_llm/schema_spec.rb[1:2:1]                     | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_spec.rb[1:2:2]                     | passed | 0.00007 seconds |
+./spec/ruby_llm/schema_spec.rb[1:2:3]                     | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_spec.rb[1:3:1]                     | passed | 0.00005 seconds |
+./spec/ruby_llm/schema_spec.rb[1:3:2]                     | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_spec.rb[1:3:3]                     | passed | 0.00004 seconds |
+./spec/ruby_llm/schema_spec.rb[1:4:1]                     | passed | 0.00006 seconds |
+./spec/ruby_llm/schema_spec.rb[1:5:1]                     | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_spec.rb[1:5:2]                     | passed | 0.00057 seconds |
+./spec/ruby_llm/schema_spec.rb[1:5:3]                     | passed | 0.00023 seconds |
+./spec/ruby_llm/schema_spec.rb[1:6:1]                     | passed | 0.00038 seconds |
+./spec/ruby_llm/schema_spec.rb[1:6:2]                     | passed | 0.00003 seconds |
+./spec/ruby_llm/schema_spec.rb[1:7:1:1]                   | passed | 0.00021 seconds |
+./spec/ruby_llm/schema_spec.rb[1:7:1:2]                   | passed | 0.00006 seconds |
+./spec/ruby_llm/schema_spec.rb[1:7:2:1]                   | passed | 0.00005 seconds |
+./spec/ruby_llm/schema_spec.rb[1:8:1]                     | passed | 0.00044 seconds |
+./spec/ruby_llm/schema_spec.rb[1:8:2]                     | passed | 0.00008 seconds |

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Daniel Friis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,221 @@
+# RubyLLM::Schema
+
+A Ruby DSL for creating JSON schemas with a clean, Rails-inspired API. Perfect for defining structured data schemas for LLM function calling or structured outputs.
+
+### Simple Example
+
+```ruby
+class PersonSchema < RubyLLM::Schema
+  string :name, description: "Person's full name"
+  number :age, description: "Age in years"
+  boolean :active, required: false
+  
+  object :address do
+    string :street
+    string :city
+    string :country, required: false
+  end
+  
+  array :tags, of: :string, description: "User tags"
+  
+  array :contacts do
+    object do
+      string :email
+      string :phone, required: false
+    end
+  end
+  
+  any_of :status do
+    string enum: ["active", "pending", "inactive"]
+    null
+  end
+end
+
+# Usage
+schema = PersonSchema.new
+puts schema.to_json
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruby_llm-schema'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install ruby_llm-schema
+```
+
+## Usage
+
+Three approaches for creating schemas:
+
+### Class Inheritance
+
+```ruby
+class PersonSchema < RubyLLM::Schema
+  string :name, description: "Person's full name"
+  number :age
+  boolean :active, required: false
+  
+  object :address do
+    string :street
+    string :city
+  end
+  
+  array :tags, of: :string
+end
+
+schema = PersonSchema.new
+puts schema.to_json
+```
+
+### Factory Method
+
+```ruby
+PersonSchema = RubyLLM::Schema.create do
+  string :name, description: "Person's full name"
+  number :age
+  boolean :active, required: false
+  
+  object :address do
+    string :street
+    string :city
+  end
+  
+  array :tags, of: :string
+end
+
+schema = PersonSchema.new
+puts schema.to_json
+```
+
+### Global Helper
+
+```ruby
+require 'ruby_llm/schema'
+include RubyLLM::Helpers
+
+person_schema = schema "PersonData", description: "A person object" do
+  string :name, description: "Person's full name"
+  number :age
+  boolean :active, required: false
+  
+  object :address do
+    string :street
+    string :city
+  end
+  
+  array :tags, of: :string
+end
+
+puts person_schema.to_json
+```
+
+## Field Types
+
+### Primitive Types
+
+```ruby
+string :name                          # Required string
+string :title, required: false        # Optional string
+string :status, enum: ["on", "off"]   # String with enum values
+number :count                         # Required number
+integer :id                           # Required integer
+boolean :active                       # Required boolean
+null :placeholder                     # Null type
+```
+
+### Arrays
+
+```ruby
+array :tags, of: :string              # Array of strings
+array :scores, of: :number            # Array of numbers
+
+array :items do                       # Array of objects
+  object do
+    string :name
+    number :price
+  end
+end
+```
+
+### Objects
+
+```ruby
+object :user do
+  string :name
+  number :age
+end
+
+object :settings, description: "User preferences" do
+  boolean :notifications
+  string :theme, enum: ["light", "dark"]
+end
+```
+
+### Union Types (anyOf)
+
+```ruby
+any_of :value do
+  string
+  number  
+  null
+end
+
+any_of :identifier do
+  string description: "Username"
+  number description: "User ID"
+end
+```
+
+### Schema Definitions and References
+
+```ruby
+class MySchema < RubyLLM::Schema
+  define :location do
+    string :latitude
+    string :longitude
+  end
+  
+  array :coordinates, of: :location
+  
+  object :home_location do
+    reference :location
+  end
+end
+```
+
+## JSON Output
+
+```ruby
+schema = PersonSchema.new
+schema.to_json_schema
+# => {
+#   name: "PersonSchema",
+#   description: nil,
+#   schema: {
+#     type: "object",
+#     properties: { ... },
+#     required: [...],
+#     additionalProperties: false,
+#     strict: true
+#   }
+# }
+
+puts schema.to_json  # Pretty JSON string
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "standard/rake"

data/lib/ruby_llm/schema/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class Schema
+    # Base error class for all schema-related errors
+    class Error < StandardError; end
+
+    # Raised when an invalid schema type is specified
+    class InvalidSchemaTypeError < Error
+      def initialize(type)
+        super("Unknown schema type: #{type}")
+      end
+    end
+
+    # Raised when an invalid array type is specified
+    class InvalidArrayTypeError < Error
+      def initialize(type)
+        super("Invalid array type: #{type}")
+      end
+    end
+
+    # Raised when schema definition is invalid
+    class InvalidSchemaError < Error; end
+
+    # Raised when schema validation fails
+    class ValidationError < Error; end
+
+    # Raised when maximum limits are exceeded
+    class LimitExceededError < Error; end
+  end
+end

data/lib/ruby_llm/schema/helpers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Helpers
+    def schema(name = nil, description: nil, &block)
+      schema_class = Schema.create(&block)
+      schema_class.new(name, description: description)
+    end
+  end
+end 

data/lib/ruby_llm/schema/property_schema_collector.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class Schema
+    class PropertySchemaCollector
+      attr_reader :schemas
+
+      def initialize
+        @schemas = []
+      end
+
+      def collect(&)
+        instance_eval(&)
+      end
+
+      def string(**options)
+        @schemas << Schema.build_property_schema(:string, **options)
+      end
+
+      def number(**options)
+        @schemas << Schema.build_property_schema(:number, **options)
+      end
+
+      def integer(**options)
+        @schemas << Schema.build_property_schema(:integer, **options)
+      end
+
+      def boolean(**options)
+        @schemas << Schema.build_property_schema(:boolean, **options)
+      end
+
+      def null(**options)
+        @schemas << Schema.build_property_schema(:null, **options)
+      end
+
+      def object(...)
+        @schemas << Schema.build_property_schema(:object, ...)
+      end
+    end
+  end
+end

data/lib/ruby_llm/schema/validator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  class Schema
+    class Validator
+      # Node states for DFS-based topological sort
+      WHITE = :white  # No mark (unvisited)
+      GRAY = :gray    # Temporary mark (currently being processed)
+      BLACK = :black  # Permanent mark (completely processed)
+
+      def initialize(schema_class)
+        @schema_class = schema_class
+      end
+
+      def validate!
+        validate_circular_references!
+        # Future validations can be added here
+      end
+
+      def valid?
+        validate!
+        true
+      rescue ValidationError
+        false
+      end
+
+      private
+
+      def validate_circular_references!
+        definitions = @schema_class.definitions
+        return if definitions.empty?
+
+        # Initialize all nodes as WHITE (no mark)
+        marks = Hash.new { WHITE }
+        
+        # Visit each unmarked node
+        definitions.each_key do |node|
+          visit(node, definitions, marks) if marks[node] == WHITE
+        end
+      end
+
+      # DFS visit function
+      def visit(node, definitions, marks)
+        # If node has a permanent mark, return
+        return if marks[node] == BLACK
+        
+        # If node has a temporary mark, we found a cycle
+        if marks[node] == GRAY
+          raise ValidationError, "Circular reference detected involving '#{node}'"
+        end
+
+        # Mark node with temporary mark
+        marks[node] = GRAY
+        
+        # Visit all adjacent nodes (dependencies)
+        definition = definitions[node]
+        if definition && definition[:properties]
+          definition[:properties].each_value do |property|
+            references = extract_references(property)
+            references.each do |adjacent_node|
+              visit(adjacent_node, definitions, marks)
+            end
+          end
+        end
+        
+        # Mark node with permanent mark
+        marks[node] = BLACK
+      end
+
+      def extract_references(property)
+        references = []
+        
+        case property
+        when Hash
+          if property["$ref"]
+            # Extract definition name from reference like "#/$defs/user"
+            ref_name = property["$ref"].split("/").last&.to_sym
+            references << ref_name if ref_name
+          else
+            # Recursively check nested properties
+            property.each_value do |value|
+              references.concat(extract_references(value))
+            end
+          end
+        when Array
+          property.each do |item|
+            references.concat(extract_references(item))
+          end
+        end
+
+        references
+      end
+    end
+  end
+end 

data/lib/ruby_llm/schema/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLlm
+  class Schema
+    VERSION = "0.1.0"
+  end
+end

data/lib/ruby_llm/schema.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require_relative "schema/version"
+require_relative "schema/property_schema_collector"
+require_relative "schema/errors"
+require_relative "schema/helpers"
+require_relative "schema/validator"
+require "json"
+require "set"
+
+module RubyLLM
+  class Schema
+    PRIMITIVE_TYPES = %i[string number integer boolean null].freeze
+
+    class << self
+      def create(&block)
+        schema_class = Class.new(Schema)
+        schema_class.class_eval(&block)
+        schema_class
+      end
+
+      def description(description = nil)
+        @description = description if description
+        @description
+      end
+
+      def additional_properties(value = nil)
+        return @additional_properties ||= false if value.nil?
+        @additional_properties = value
+      end
+
+      def strict(value = nil)
+        return @strict ||= true if value.nil?
+        @strict = value
+      end
+
+      def string(name = nil, enum: nil, description: nil, required: true)
+        add_property(name, build_property_schema(:string, enum: enum, description: description), required: required)
+      end
+
+      def number(name = nil, description: nil, required: true)
+        add_property(name, build_property_schema(:number, description: description), required: required)
+      end
+
+      def integer(name = nil, description: nil, required: true)
+        add_property(name, build_property_schema(:integer, description: description), required: required)
+      end
+
+      def boolean(name = nil, description: nil, required: true)
+        add_property(name, build_property_schema(:boolean, description: description), required: required)
+      end
+
+      def null(name = nil, description: nil, required: true)
+        add_property(name, build_property_schema(:null, description: description), required: required)
+      end
+
+      def object(name = nil, description: nil, required: true, &block)
+        add_property(name, build_property_schema(:object, description: description, &block), required: required)
+      end
+
+      def array(name, of: nil, description: nil, required: true, &block)
+        items = determine_array_items(of, &block)
+
+        add_property(name, {
+          type: "array",
+          description: description,
+          items: items
+        }.compact, required: required)
+      end
+
+      def any_of(name, required: true, description: nil, &block)
+        schemas = collect_property_schemas_from_block(&block)
+
+        add_property(name, {
+          description: description,
+          anyOf: schemas
+        }.compact, required: required)
+      end
+
+      def define(name, &)
+        sub_schema = Class.new(Schema)
+        sub_schema.class_eval(&)
+
+        definitions[name] = {
+          type: "object",
+          properties: sub_schema.properties,
+          required: sub_schema.required_properties
+        }
+      end
+
+      def reference(schema_name)
+        {"$ref" => "#/$defs/#{schema_name}"}
+      end
+
+      def properties
+        @properties ||= {}
+      end
+
+      def required_properties
+        @required_properties ||= []
+      end
+
+      def definitions
+        @definitions ||= {}
+      end
+
+      def build_property_schema(type, **options, &)
+        case type
+        when :string
+          {type: "string", enum: options[:enum], description: options[:description]}.compact
+        when :number
+          {type: "number", description: options[:description]}.compact
+        when :integer
+          {type: "integer", description: options[:description]}.compact
+        when :boolean
+          {type: "boolean", description: options[:description]}.compact
+        when :null
+          {type: "null", description: options[:description]}.compact
+        when :object
+          sub_schema = Class.new(Schema)
+          sub_schema.class_eval(&)
+
+          {
+            type: "object",
+            properties: sub_schema.properties,
+            required: sub_schema.required_properties,
+            additionalProperties: additional_properties,
+            description: options[:description]
+          }.compact
+        else
+          raise InvalidSchemaTypeError, type
+        end
+      end
+
+      def validate!
+        validator = Validator.new(self)
+        validator.validate!
+      end
+
+      def valid?
+        validator = Validator.new(self)
+        validator.valid?
+      end
+
+      private
+
+      def add_property(name, definition, required:)
+        properties[name.to_sym] = definition
+        required_properties << name.to_sym if required
+      end
+
+      def determine_array_items(of, &)
+        return collect_property_schemas_from_block(&).first if block_given?
+        return build_property_schema(of) if primitive_type?(of)
+        return reference(of) if of.is_a?(Symbol)
+
+        raise InvalidArrayTypeError, of
+      end
+
+      def collect_property_schemas_from_block(&)
+        collector = PropertySchemaCollector.new
+        collector.collect(&)
+        collector.schemas
+      end
+
+      def primitive_type?(type)
+        type.is_a?(Symbol) && PRIMITIVE_TYPES.include?(type)
+      end
+    end
+
+    def initialize(name = nil, description: nil)
+      @name = name || self.class.name || "Schema"
+      @description = description
+    end
+
+    def to_json_schema
+      validate!  # Validate schema before generating JSON
+      
+      {
+        name: @name,
+        description: @description,
+        schema: {
+          :type => "object",
+          :properties => self.class.properties,
+          :required => self.class.required_properties,
+          :additionalProperties => self.class.additional_properties,
+          :strict => self.class.strict,
+          "$defs" => self.class.definitions
+        }
+      }
+    end
+
+    def to_json(*_args)
+      validate!  # Validate schema before generating JSON string
+      JSON.pretty_generate(to_json_schema)
+    end
+
+    def validate!
+      self.class.validate!
+    end
+
+    def valid?
+      self.class.valid?
+    end
+
+    def method_missing(method_name, ...)
+      if respond_to_missing?(method_name)
+        send(method_name, ...)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      %i[string number integer boolean array object any_of null].include?(method_name) || super
+    end
+  end
+end

data/lib/tasks/release.rake

@@ -0,0 +1,13 @@
+namespace :release do
+  desc "Release a new version of the gem"
+  task :version do
+    puts "Enter the new version: "
+    version = gets.chomp
+    system "git tag v#{version}"
+    system "git push origin v#{version}"
+
+    system "gem build ruby_llm-schema.gemspec"
+    system "gem push ruby_llm-schema-#{version}.gem"
+    system "rm ruby_llm-schema-#{version}.gem"
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: ruby_llm-schema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Friis
+bindir: exe
+cert_chain: []
+date: 2025-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- d@friis.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rspec_status"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ruby_llm/schema.rb
+- lib/ruby_llm/schema/errors.rb
+- lib/ruby_llm/schema/helpers.rb
+- lib/ruby_llm/schema/property_schema_collector.rb
+- lib/ruby_llm/schema/validator.rb
+- lib/ruby_llm/schema/version.rb
+- lib/tasks/release.rake
+homepage: https://github.com/danielfriis/ruby_llm-schema
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/danielfriis/ruby_llm-schema
+  source_code_uri: https://github.com/danielfriis/ruby_llm-schema
+  changelog_uri: https://github.com/danielfriis/ruby_llm-schema/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A simple and clean Ruby DSL for creating JSON schemas.
+test_files: []