ruby_llm-schema 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fceccc2292efb7c17ce5457a08d6a18ddc3debd920052a1d8e368d74e450547e
-  data.tar.gz: b16fafc541af3b9f1a1e3a96f81be21175a380606f2e40325afa29d76108daea
+  metadata.gz: 6bfabbb94f9550f5bae72fc6ad6046ba1fa6f9e99723c4fea969822bd76f33f9
+  data.tar.gz: 5b97078d6f40a912a366c4d8f26333ead3504126e9a2abd3d8d658f81d168283
 SHA512:
-  metadata.gz: 984b11c9fcfcaf68f0892a9a7b9c10064436aa59279f0a0992ebae5c6d20fbcfd1e6afbef8376bf7a9239aaaea246dd9f8c7f6a3d9521509789c8e334e3e0363
-  data.tar.gz: e9658cff5e3e1f0912eab47fe8438a5dfd5bf52928dd0198ff39131ecf1aeb5d3b2a8e08344feab0b363ed6a9a27747c1489fcfadefd8f30af4d03c77fb601d8
+  metadata.gz: adc5528fd26d989854bbf0d6255bda4123fa6df18d96722c38b47a7414ff8c53006212f8c987932d190913553bad3764870038589ebb20a070ebc38e034de87c
+  data.tar.gz: 85d522c3b21f5949ce3ed5dba3aef643836d16b5daaca44c2d6a8beeec67e6cfae65ca126e4dbd49edf434f0134aeecb715216c6f3da793d0445a38baa2442fb

data/README.md

@@ -1,468 +1,28 @@
-# RubyLLM::Schema
+# ruby_llm-schema (deprecated)
 
-[![Gem Version](https://badge.fury.io/rb/ruby_llm-schema.svg)](https://rubygems.org/gems/ruby_llm-schema)
-[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/crmne/ruby_llm-schema/blob/main/LICENSE)
-[![CI](https://github.com/crmne/ruby_llm-schema/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/crmne/ruby_llm-schema/actions/workflows/main.yml)
+This gem is now [schematist](https://github.com/crmne/schematist). This directory holds the
+final `ruby_llm-schema` release, which does nothing but depend on schematist and alias
+`RubyLLM::Schema` to `Schematist::Schema`.
 
-A Ruby DSL for creating JSON schemas with a clean, Rails-inspired API.
+It lives in the schematist repo rather than its own, so the alias cannot drift from the gem
+it forwards to. The spec suite loads it and checks the aliases still resolve.
 
-Originally created by [Daniel Friis](https://github.com/danielfriis).
+## Building and releasing
 
-## Use Cases
-
-JSON Schema is useful wherever Ruby code needs to describe structured data in a portable format.
-
-Some ideal use cases:
-
-- Defining API request and response shapes
-- Describing configuration files or structured payloads
-- Sharing validation contracts across systems
-- Generating structured output schemas for LLM workflows
-- Defining structured parameters for RubyLLM tools
-
-### Simple Example
-
-```ruby
-class PersonSchema < RubyLLM::Schema
-  string :name, description: "Person's full name"
-  number :age, description: "Age in years", minimum: 0, maximum: 120
-  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, format: "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
-```
-
-### RubyLLM structured output
-
-```ruby
-class PersonSchema < RubyLLM::Schema
-  string :name, description: "Person's full name"
-  integer :age, description: "Person's age in years"
-  string :city, required: false, description: "City where they live"
-end
-
-# Use it natively with RubyLLM
-chat     = RubyLLM.chat
-response = chat.with_schema(PersonSchema)
-               .ask("Generate a person named Alice who is 30 years old and lives in New York")
-
-# The response is automatically parsed from JSON
-puts response.content # => {"name" => "Alice", "age" => 30}
-puts response.content.class # => Hash
-```
-
-### RubyLLM tools
-
-RubyLLM tools can use schema classes for structured parameters. This is useful when the same argument shape is shared across tools or elsewhere in your app.
-
-```ruby
-class SearchParams < RubyLLM::Schema
-  string :query, description: "Search query"
-  integer :limit, required: false, description: "Maximum results"
-end
-
-class SearchDocuments < RubyLLM::Tool
-  desc "Searches internal documents"
-  params SearchParams
-
-  def execute(query:, limit: 10)
-    DocumentSearch.call(query:, limit:)
-  end
-end
-```
-
-For tool-specific parameters, define the schema inline with `params do ... end`.
-
-```ruby
-class Weather < RubyLLM::Tool
-  desc "Gets current weather"
-
-  params do
-    string :city, description: "City name"
-    string :units, enum: %w[celsius fahrenheit], required: false
-  end
-
-  def execute(city:, units: "celsius")
-    WeatherAPI.current(city:, units:)
-  end
-end
-```
-
-## 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:
+The root gemspec builds schematist. This one has to be built from this directory:
 
 ```bash
-gem install ruby_llm-schema
+cd compat/ruby_llm-schema
+gem build ruby_llm-schema.gemspec
+gem push ruby_llm-schema-1.0.0.gem
 ```
 
-## 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
-```
-
-## Schema Property Types
-
-A schema is a collection of properties, which can be of different types. Each type has its own set of properties you can set.
-
-All property types can (along with the required `name` key) be set with a `description` and a `required` flag (default is `true`).
+schematist 1.0.0 must be on RubyGems first, since this gem depends on it.
 
-```ruby
-string :name, description: "Person's full name"
-number :age, description: "Person's age", required: false
-boolean :is_active, description: "Whether the person is active"
-null :placeholder, description: "A placeholder property"
-```
-
-⚠️ Please consult the LLM provider documentation for any limitations or restrictions. For example, as of now, OpenAI requires all properties to be required. In that case, you can use the `any_of` method to make a property optional.
-
-```ruby
-any_of :name, description: "Person's full name" do
-  string
-  null
-end
-```
-
-### Strings
-
-String types support the following properties:
-
-- `enum`: an array of allowed values (e.g. `enum: ["on", "off"]`)
-- `pattern`: a regex pattern (e.g. `pattern: "\\d+"`)
-- `format`: a format string (e.g. `format: "email"`)
-- `min_length`: the minimum length of the string (e.g. `min_length: 3`)
-- `max_length`: the maximum length of the string (e.g. `max_length: 10`)
-
-Please consult the LLM provider documentation for the available formats and patterns.
-
-```ruby
-string :name, description: "Person's full name"
-string :email, format: "email"
-string :phone, pattern: "\\d+"
-string :status, enum: ["on", "off"]
-string :code, min_length: 3, max_length: 10
-```
-
-### Numbers
-
-Number types support the following properties:
-
-- `multiple_of`: a multiple of the number (e.g. `multiple_of: 0.01`)
-- `minimum`: the minimum value of the number (e.g. `minimum: 0`)
-- `maximum`: the maximum value of the number (e.g. `maximum: 100`)
-
-```ruby
-number :price, minimum: 0, maximum: 100
-number :amount, multiple_of: 0.01
-```
-
-### Booleans
-
-```ruby
-boolean :is_active
-```
-
-Boolean types doesn't support any additional properties.
-
-### Null
-
-```ruby
-null :placeholder
-```
-
-Null types doesn't support any additional properties.
-
-### Arrays
-
-An array is a list of items. You can set the type of the items in the array with the `of` option or by passing a block with the `object` method.
-
-An array can have a `min_items` and `max_items` option to set the minimum and maximum number of items in the array.
-
-```ruby
-array :tags, of: :string              # Array of strings
-array :scores, of: :number            # Array of numbers
-array :items, min_items: 1, max_items: 10  # Array with size constraints
-
-array :items do                       # Array of objects
-  object do
-    string :name
-    number :price
-  end
-end
-```
-
-### Objects
-
-Objects types expect a block with the properties of the object.
-
-```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)
-
-Union types are a way to specify that a property can be one of several types.
-
-```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
-
-You can define sub-schemas and reference them in other schemas, or reference the root schema to generate recursive schemas.
-
-```ruby
-class MySchema < RubyLLM::Schema
-  define :location do
-    string :latitude
-    string :longitude
-  end
-
-  # Using a reference in an array
-  array :coordinates, of: :location
-
-  # Using a reference in an object via the `reference` option
-  object :home_location, reference: :location
-
-  # Using a reference in an object via block
-  object :user do
-    reference :location
-  end
-
-  # Using a reference to the root schema
-  object :ui_schema do
-    string :element, enum: ["input", "button"]
-    string :label
-    object :sub_schema, reference: :root
-  end
-end
-```
-
-### Nested Schemas
-
-You can embed existing schema classes directly within objects or arrays for reusable schema composition.
-
-```ruby
-class PersonSchema < RubyLLM::Schema
-  string :name
-  integer :age
-end
-
-class CompanySchema < RubyLLM::Schema
-  # Using 'of' parameter
-  object :ceo, of: PersonSchema
-  array :employees, of: PersonSchema
-
-  # Using Schema.new in block
-  object :founder do
-    PersonSchema.new
-  end
-end
-
-schema = CompanySchema.new
-schema.to_json_schema
-# =>
-# {
-#    "name":"CompanySchema",
-#    "description":"nil",
-#    "schema":{
-#       "type":"object",
-#       "properties":{
-#          "ceo":{
-#             "type":"object",
-#             "properties":{
-#                "name":{
-#                   "type":"string"
-#                },
-#                "age":{
-#                   "type":"integer"
-#                }
-#             },
-#             "required":[
-#                :"name",
-#                :"age"
-#             ],
-#             "additionalProperties":false
-#          },
-#          "employees":{
-#             "type":"array",
-#             "items":{
-#                "type":"object",
-#                "properties":{
-#                   "name":{
-#                      "type":"string"
-#                   },
-#                   "age":{
-#                      "type":"integer"
-#                   }
-#                },
-#                "required":[
-#                   :"name",
-#                   :"age"
-#                ],
-#                "additionalProperties":false
-#             }
-#          },
-#          "founder":{
-#             "type":"object",
-#             "properties":{
-#                "name":{
-#                   "type":"string"
-#                },
-#                "age":{
-#                   "type":"integer"
-#                }
-#             },
-#             "required":[
-#                :"name",
-#                :"age"
-#             ],
-#             "additionalProperties":false
-#          }
-#       },
-#       "required":[
-#          :"ceo",
-#          :"employees",
-#          :"founder"
-#       ],
-#       "additionalProperties":false,
-#       "strict":true
-#    }
-# }
-```
-
-## 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
-```
+The version tracks the schematist release it forwards to.
 
-## License
+## What the alias cannot forward
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+- `strict` was removed. It is an OpenAI `response_format` flag, not a JSON Schema keyword.
+- `to_json_schema` returns a Draft 2020-12 document with string keys, not the
+  `{name:, description:, schema:}` provider envelope. Build that envelope where you send it.

data/lib/ruby_llm/schema.rb

@@ -1,99 +1,31 @@
 # frozen_string_literal: true
 
-require_relative "schema/version"
-require_relative "schema/errors"
-require_relative "schema/helpers"
-require_relative "schema/validator"
-require_relative "schema/dsl"
-require_relative "schema/json_output"
-require "json"
+require "schematist"
 
-module RubyLLM
-  class Schema
-    extend DSL
-    include JsonOutput
-
-    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 properties
-        @properties ||= {}
-      end
-
-      def required_properties
-        @required_properties ||= []
-      end
-
-      def definitions
-        @definitions ||= {}
-      end
-
-      def name(name = nil)
-        @schema_name = name if name
-        return @schema_name if defined?(@schema_name)
-
-        super()
-      end
-
-      def description(description = nil)
-        @description = description if description
-        @description
-      end
+warn <<~DEPRECATION
+  [DEPRECATION] ruby_llm-schema is now schematist, and this gem only forwards to it.
 
-      def additional_properties(value = nil)
-        return @additional_properties ||= false if value.nil?
+    gem 'schematist'                        # was: gem 'ruby_llm-schema'
+    class Person < Schematist::Schema; end  # was: RubyLLM::Schema
 
-        @additional_properties = value
-      end
+  Two things the aliases below cannot forward: `strict` is gone, since it is an OpenAI
+  response_format flag rather than a JSON Schema keyword, and `to_json_schema` now returns
+  a Draft 2020-12 document instead of the provider envelope. See
+  https://github.com/crmne/schematist#migrating-from-ruby_llm-schema
+DEPRECATION
 
-      def strict(*args)
-        if args.empty?
-          instance_variable_defined?(:@strict) ? @strict : true
-        else
-          @strict = args.first
-        end
-      end
-
-      def validate!
-        validator = Validator.new(self)
-        validator.validate!
-      end
-
-      def valid?
-        validator = Validator.new(self)
-        validator.valid?
-      end
-    end
-
-    def initialize(name = nil, description: nil)
-      @name = name || self.class.name || "Schema"
-      @description = description
-    end
-
-    def validate!
-      self.class.validate!
-    end
-
-    def valid?
-      self.class.valid?
-    end
-
-    def method_missing(method_name, ...)
-      if respond_to_missing?(method_name)
-        self.class.send(method_name, ...)
-      else
-        super
-      end
-    end
+module RubyLLM
+  Schema = Schematist::Schema
+  Helpers = Schematist::Helpers
+end
 
-    def respond_to_missing?(method_name, include_private = false)
-      %i[string number integer boolean array object any_of one_of null].include?(method_name) || super
-    end
-  end
+# The error hierarchy moved from RubyLLM::Schema::X to Schematist::X. RubyLLM::Schema and
+# Schematist::Schema are the same object, so these also become reachable as
+# Schematist::Schema::X. Harmless — they are aliases to the very same classes — and it is
+# the only way to keep `rescue RubyLLM::Schema::ValidationError` working.
+%i[
+  Error InvalidSchemaTypeError InvalidArrayTypeError InvalidObjectTypeError
+  InvalidSchemaError ValidationError LimitExceededError
+].each do |name|
+  RubyLLM::Schema.const_set(name, Schematist.const_get(name))
 end

metadata

@@ -1,45 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-schema
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Daniel Friis
+- Carmine Paolino
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
-description: A compact Ruby DSL for building standards-oriented JSON Schema documents
-  from Ruby.
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: schematist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Forwards RubyLLM::Schema to Schematist::Schema. Depend on schematist
+  instead.
 email:
 - d@friis.me
+- carmine@paolino.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
 - README.md
 - lib/ruby_llm/schema.rb
-- lib/ruby_llm/schema/dsl.rb
-- lib/ruby_llm/schema/dsl/complex_types.rb
-- lib/ruby_llm/schema/dsl/primitive_types.rb
-- lib/ruby_llm/schema/dsl/schema_builders.rb
-- lib/ruby_llm/schema/dsl/utilities.rb
-- lib/ruby_llm/schema/errors.rb
-- lib/ruby_llm/schema/helpers.rb
-- lib/ruby_llm/schema/json_output.rb
-- lib/ruby_llm/schema/validator.rb
-- lib/ruby_llm/schema/version.rb
-- lib/tasks/release.rake
-homepage: https://github.com/crmne/ruby_llm-schema#readme
+homepage: https://github.com/crmne/schematist#migrating-from-ruby_llm-schema
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/crmne/ruby_llm-schema#readme
-  source_code_uri: https://github.com/crmne/ruby_llm-schema
-  changelog_uri: https://github.com/crmne/ruby_llm-schema/releases
-  bug_tracker_uri: https://github.com/crmne/ruby_llm-schema/issues
+  homepage_uri: https://github.com/crmne/schematist#migrating-from-ruby_llm-schema
+  source_code_uri: https://github.com/crmne/schematist
+  changelog_uri: https://github.com/crmne/schematist/releases
+  bug_tracker_uri: https://github.com/crmne/schematist/issues
   rubygems_mfa_required: 'true'
+post_install_message: |
+  ruby_llm-schema is now schematist. This release only forwards to it.
+  Switch your Gemfile to `gem 'schematist'` and RubyLLM::Schema to Schematist::Schema.
 rdoc_options: []
 require_paths:
 - lib
@@ -54,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
-summary: A simple Ruby DSL for creating JSON schemas.
+summary: Deprecated. ruby_llm-schema is now schematist.
 test_files: []

data/LICENSE

@@ -1,21 +0,0 @@
-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/lib/ruby_llm/schema/dsl/complex_types.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module ComplexTypes
-        def object(name, description: nil, required: true, **options, &block)
-          add_property(name, object_schema(description: description, **options, &block), required: required)
-        end
-
-        def array(name, description: nil, required: true, **options, &block)
-          add_property(name, array_schema(description: description, **options, &block), required: required)
-        end
-
-        def any_of(name, description: nil, required: true, **options, &block)
-          add_property(name, any_of_schema(description: description, **options, &block), required: required)
-        end
-
-        def one_of(name, description: nil, required: true, **options, &block)
-          add_property(name, one_of_schema(description: description, **options, &block), required: required)
-        end
-
-        def optional(name, description: nil, &block)
-          any_of(name, description: description) do
-            instance_eval(&block)
-            null
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl/primitive_types.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module PrimitiveTypes
-        def string(name, description: nil, required: true, **options)
-          add_property(name, string_schema(description: description, **options), required: required)
-        end
-
-        def number(name, description: nil, required: true, **options)
-          add_property(name, number_schema(description: description, **options), required: required)
-        end
-
-        def integer(name, description: nil, required: true, **options)
-          add_property(name, integer_schema(description: description, **options), required: required)
-        end
-
-        def boolean(name, description: nil, required: true, **options)
-          add_property(name, boolean_schema(description: description, **options), required: required)
-        end
-
-        def null(name, description: nil, required: true, **options)
-          add_property(name, null_schema(description: description, **options), required: required)
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl/schema_builders.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module SchemaBuilders
-        def string_schema(description: nil, enum: nil, min_length: nil, max_length: nil, pattern: nil, format: nil)
-          {
-            type: "string",
-            enum: enum,
-            description: description,
-            minLength: min_length,
-            maxLength: max_length,
-            pattern: pattern,
-            format: format
-          }.compact
-        end
-
-        def number_schema(description: nil, minimum: nil, maximum: nil, multiple_of: nil)
-          {
-            type: "number",
-            description: description,
-            minimum: minimum,
-            maximum: maximum,
-            multipleOf: multiple_of
-          }.compact
-        end
-
-        def integer_schema(description: nil, minimum: nil, maximum: nil, multiple_of: nil)
-          {
-            type: "integer",
-            description: description,
-            minimum: minimum,
-            maximum: maximum,
-            multipleOf: multiple_of
-          }.compact
-        end
-
-        def boolean_schema(description: nil)
-          {type: "boolean", description: description}.compact
-        end
-
-        def null_schema(description: nil)
-          {type: "null", description: description}.compact
-        end
-
-        def object_schema(description: nil, of: nil, reference: nil, &block)
-          if reference
-            warn "[DEPRECATION] The `reference` option will be deprecated. Please use `of` instead."
-            of = reference
-          end
-
-          if of
-            determine_object_reference(of, description)
-          else
-            sub_schema = Class.new(Schema)
-            result = sub_schema.class_eval(&block)
-
-            # If the block returned a reference and no properties were added, use the reference
-            if result.is_a?(Hash) && result["$ref"] && sub_schema.properties.empty?
-              result.merge(description ? {description: description} : {})
-            # If the block returned a Schema class or instance, convert it to inline schema
-            elsif schema_class?(result) && sub_schema.properties.empty?
-              schema_class_to_inline_schema(result).merge(description ? {description: description} : {})
-            # Block didn't return reference or schema, so we build an inline object schema
-            else
-              {
-                type: "object",
-                properties: sub_schema.properties,
-                required: sub_schema.required_properties,
-                additionalProperties: sub_schema.additional_properties,
-                description: description
-              }.compact
-            end
-          end
-        end
-
-        def array_schema(description: nil, of: nil, min_items: nil, max_items: nil, &block)
-          items = determine_array_items(of, &block)
-
-          {
-            type: "array",
-            description: description,
-            items: items,
-            minItems: min_items,
-            maxItems: max_items
-          }.compact
-        end
-
-        def any_of_schema(description: nil, &block)
-          schemas = collect_schemas_from_block(&block)
-
-          {
-            description: description,
-            anyOf: schemas
-          }.compact
-        end
-
-        def one_of_schema(description: nil, &block)
-          schemas = collect_schemas_from_block(&block)
-
-          {
-            description: description,
-            oneOf: schemas
-          }.compact
-        end
-
-        private
-
-        def determine_array_items(of, &)
-          return collect_schemas_from_block(&).first if block_given?
-          return send("#{of}_schema") if primitive_type?(of)
-          return reference(of) if of.is_a?(Symbol)
-          return schema_class_to_inline_schema(of) if schema_class?(of)
-
-          raise InvalidArrayTypeError, "Invalid array type: #{of.inspect}. Must be a primitive type (:string, :number, etc.), a symbol reference, a Schema class, or a Schema instance."
-        end
-
-        def determine_object_reference(of, description = nil)
-          result = case of
-                   when Symbol
-                     reference(of)
-                   when Class
-                     raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Class must inherit from RubyLLM::Schema." unless schema_class?(of)
-
-                     schema_class_to_inline_schema(of)
-
-                   else
-                     raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Must be a symbol reference, a Schema class, or a Schema instance." unless schema_class?(of)
-
-                     schema_class_to_inline_schema(of)
-
-                   end
-
-          description ? result.merge(description: description) : result
-        end
-
-        def collect_schemas_from_block(&block)
-          schemas = []
-          schema_builder = self
-
-          context = Object.new
-
-          # Dynamically create methods for all schema builders
-          schema_builder.methods.grep(/_schema$/).each do |schema_method|
-            type_name = schema_method.to_s.sub(/_schema$/, "")
-
-            context.define_singleton_method(type_name) do |_name = nil, **options, &blk|
-              schemas << schema_builder.send(schema_method, **options, &blk)
-            end
-          end
-
-          # Allow Schema classes to be accessed in the context
-          context.define_singleton_method(:const_missing) do |name|
-            const_get(name) if const_defined?(name)
-          end
-
-          context.instance_eval(&block)
-          schemas
-        end
-
-        def schema_class_to_inline_schema(schema_class_or_instance)
-          # Handle both Schema classes and Schema instances
-          schema_class = if schema_class_or_instance.is_a?(Class)
-                           schema_class_or_instance
-                         else
-                           schema_class_or_instance.class
-                         end
-
-          # Directly convert schema class to inline object schema
-          {
-            type: "object",
-            properties: schema_class.properties,
-            required: schema_class.required_properties,
-            additionalProperties: schema_class.additional_properties
-          }.tap do |schema|
-            # For instances, prefer instance description over class description
-            description = if schema_class_or_instance.is_a?(Class)
-                            schema_class.description
-                          else
-                            schema_class_or_instance.instance_variable_get(:@description) || schema_class.description
-                          end
-            schema[:description] = description if description
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl/utilities.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module DSL
-      module Utilities
-        # Schema definition and reference methods
-        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,
-            additionalProperties: sub_schema.additional_properties
-          }
-        end
-
-        def reference(schema_name)
-          if schema_name == :root
-            {"$ref" => "#"}
-          else
-            {"$ref" => "#/$defs/#{schema_name}"}
-          end
-        end
-
-        private
-
-        def add_property(name, definition, required:)
-          property_name = name.to_sym
-
-          properties[property_name] = definition
-          if required
-            required_properties << property_name unless required_properties.include?(property_name)
-          else
-            required_properties.delete(property_name)
-          end
-
-          nil
-        end
-
-        def primitive_type?(type)
-          type.is_a?(Symbol) && PRIMITIVE_TYPES.include?(type)
-        end
-
-        def schema_class?(type)
-          (type.is_a?(Class) && type < Schema) || type.is_a?(Schema)
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/dsl.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "dsl/schema_builders"
-require_relative "dsl/primitive_types"
-require_relative "dsl/complex_types"
-require_relative "dsl/utilities"
-
-module RubyLLM
-  class Schema
-    module DSL
-      include SchemaBuilders
-      include PrimitiveTypes
-      include ComplexTypes
-      include Utilities
-    end
-  end
-end

data/lib/ruby_llm/schema/errors.rb

@@ -1,30 +0,0 @@
-# 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; end
-
-    # Raised when an invalid object type is specified
-    class InvalidObjectTypeError < Error; 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

@@ -1,10 +0,0 @@
-# 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/json_output.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    module JsonOutput
-      def to_json_schema
-        validate! # Validate schema before generating JSON
-
-        schema_hash = {
-          type: "object",
-          properties: self.class.properties,
-          required: self.class.required_properties,
-          additionalProperties: self.class.additional_properties
-        }
-
-        schema_hash[:strict] = self.class.strict unless self.class.strict.nil?
-
-        # Only include $defs if there are definitions
-        schema_hash["$defs"] = self.class.definitions unless self.class.definitions.empty?
-
-        {
-          name: @name,
-          description: @description || self.class.description,
-          schema: schema_hash
-        }
-      end
-
-      def to_json(*_args)
-        validate! # Validate schema before generating JSON string
-        JSON.pretty_generate(to_json_schema)
-      end
-    end
-  end
-end

data/lib/ruby_llm/schema/validator.rb

@@ -1,93 +0,0 @@
-# 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
-        raise ValidationError, "Circular reference detected involving '#{node}'" if marks[node] == GRAY
-
-        # 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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  class Schema
-    VERSION = '0.3.1'
-  end
-end

data/lib/tasks/release.rake

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-namespace :release do
-  desc 'Prepare for release'
-  task :prepare do
-    sh 'overcommit --run'
-  end
-end