easy_talk 2.0.0 → 3.1.0

data/README.md

@@ -11,11 +11,14 @@ EasyTalk is a Ruby library that simplifies defining and generating JSON Schema.
 ### Key Features
 * **Intuitive Schema Definition**: Use Ruby classes and methods to define JSON Schema documents easily.
 * **Automatic ActiveModel Validations**: Schema constraints automatically generate corresponding ActiveModel validations (configurable).
-* **Works for plain Ruby classes and ActiveRecord models**: Integrate with existing code or build from scratch.
+* **Works for plain Ruby classes and ActiveModel classes**: Integrate with existing code or build from scratch.
 * **LLM Function Support**: Ideal for integrating with Large Language Models (LLMs) such as OpenAI's GPT series. EasyTalk enables you to effortlessly create JSON Schema documents describing the inputs and outputs of LLM function calls.
 * **Schema Composition**: Define EasyTalk models and reference them in other EasyTalk models to create complex schemas.
 * **Enhanced Model Integration**: Automatic instantiation of nested EasyTalk models from hash attributes.
 * **Flexible Configuration**: Global and per-model configuration options for fine-tuned control.
+* **JSON Schema Version Support**: Configure the `$schema` keyword to declare which JSON Schema draft version your schemas conform to (Draft-04 through Draft 2020-12).
+* **Schema Identification**: Configure the `$id` keyword to provide a unique identifier URI for your schemas.
+* **Schema References**: Use `$ref` and `$defs` for reusable schema definitions, reducing duplication when models are used in multiple places.
 
 ### Use Cases
 - API request/response validation
@@ -518,119 +521,6 @@ user.address.class # => Address (automatically instantiated)
 user.address.street # => "123 Main St"
 ```
 
-## ActiveRecord Integration
-
-### Automatic Schema Generation
-For ActiveRecord models, EasyTalk automatically generates a schema based on the database columns:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-end
-```
-
-This will create a schema with properties for each column in the `products` table.
-
-### Enhancing Generated Schemas
-You can enhance the auto-generated schema with the `enhance_schema` method:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    title: "Retail Product",
-    description: "A product available for purchase",
-    properties: {
-      name: {
-        description: "Product display name",
-        title: "Product Name"
-      },
-      price: {
-        description: "Retail price in USD"
-      }
-    }
-  })
-end
-```
-
-### Column Exclusion Options
-EasyTalk provides several ways to exclude columns from your JSON schema:
-
-#### 1. Global Configuration
-
-```ruby
-EasyTalk.configure do |config|
-  # Exclude specific columns by name from all models
-  config.excluded_columns = [:created_at, :updated_at, :deleted_at]
-  
-  # Exclude all foreign key columns (columns ending with '_id')
-  config.exclude_foreign_keys = true   # Default: false
-  
-  # Exclude all primary key columns ('id')
-  config.exclude_primary_key = true    # Default: true
-  
-  # Exclude timestamp columns ('created_at', 'updated_at')
-  config.exclude_timestamps = true     # Default: true
-  
-  # Exclude all association properties
-  config.exclude_associations = true   # Default: false
-end
-```
-
-#### 2. Model-Specific Column Ignoring
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    ignore: [:internal_ref_id, :legacy_code]  # Model-specific exclusions
-  })
-end
-```
-
-### Virtual Properties
-You can add properties that don't exist as database columns:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    properties: {
-      full_details: {
-        virtual: true,
-        type: :string,
-        description: "Complete product information"
-      }
-    }
-  })
-end
-```
-
-### Associations and Foreign Keys
-By default, EasyTalk includes your model's associations in the schema:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  belongs_to :category
-  has_many :reviews
-end
-```
-
-This will include `category` (as an object) and `reviews` (as an array) in the schema.
-
-You can control this behavior with configuration:
-
-```ruby
-EasyTalk.configure do |config|
-  config.exclude_associations = true    # Don't include associations  
-  config.exclude_foreign_keys = true    # Don't include foreign key columns
-end
-```
-
 ## Advanced Features
 
 ### LLM Function Generation
@@ -698,19 +588,14 @@ You can configure EasyTalk globally:
 
 ```ruby
 EasyTalk.configure do |config|
-  # ActiveRecord integration options
-  config.excluded_columns = [:created_at, :updated_at, :deleted_at]
-  config.exclude_foreign_keys = true
-  config.exclude_primary_key = true
-  config.exclude_timestamps = true
-  config.exclude_associations = false
-  
   # Schema behavior options
-  config.default_additional_properties = false
-  config.nilable_is_optional = false  # Makes T.nilable properties also optional
-  
-  # NEW in v2.0.0: Automatic validation generation
-  config.auto_validations = true      # Automatically generate ActiveModel validations
+  config.default_additional_properties = false  # Control additional properties on all models
+  config.nilable_is_optional = false           # Makes T.nilable properties also optional
+  config.auto_validations = true               # Automatically generate ActiveModel validations
+  config.schema_version = :none                # JSON Schema version for $schema keyword
+                                               # Options: :none, :draft202012, :draft201909, :draft7, :draft6, :draft4
+  config.schema_id = nil                       # Base URI for $id keyword (nil = no $id)
+  config.use_refs = false                      # Use $ref for nested models instead of inlining
 end
 ```
 
@@ -738,45 +623,18 @@ end
 ```
 
 ### Per-Model Configuration
-Some settings can be configured per model:
+You can configure additional properties for individual models:
 
 ```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    additionalProperties: true,
-    ignore: [:internal_ref_id, :legacy_code]
-  })
-end
-```
-
-### Exclusion Rules
-Columns are excluded based on the following rules (in order of precedence):
-
-1. Explicitly listed in `excluded_columns` global setting
-2. Listed in the model's `schema_enhancements[:ignore]` array
-3. Is a primary key when `exclude_primary_key` is true (default)
-4. Is a timestamp column when `exclude_timestamps` is true (default)
-5. Matches a foreign key pattern when `exclude_foreign_keys` is true
-
-### Customizing Output
-You can customize the JSON Schema output by enhancing the schema:
-
-```ruby
-class User < ActiveRecord::Base
+class User
   include EasyTalk::Model
   
-  enhance_schema({
-    title: "User Account",
-    description: "User account information",
-    properties: {
-      name: {
-        title: "Full Name",
-        description: "User's full name"
-      }
-    }
-  })
+  define_schema do
+    title "User"
+    additional_properties true  # Allow arbitrary additional properties on this model
+    property :name, String
+    property :email, String, format: "email"
+  end
 end
 ```
 
@@ -1277,7 +1135,7 @@ EasyTalk.configure do |config|
   
   # Existing options (unchanged)
   config.nilable_is_optional = false
-  config.exclude_foreign_keys = true
+  config.default_additional_properties = false
   # ... other existing config
 end
 ```
@@ -1287,7 +1145,7 @@ end
 - **Ruby Version**: Still requires Ruby 3.2+
 - **Dependencies**: Core dependencies remain the same
 - **JSON Schema Output**: No changes to generated schemas
-- **ActiveRecord Integration**: Fully backward compatible
+- **ActiveModel Integration**: Fully backward compatible
 
 ## Development and Contributing
 
@@ -1317,17 +1175,657 @@ bundle exec rubocop
 ### Contributing Guidelines
 Bug reports and pull requests are welcome on GitHub at https://github.com/sergiobayona/easy_talk.
 
+## JSON Schema Version (`$schema` Keyword)
+
+The `$schema` keyword declares which JSON Schema dialect (draft version) a schema conforms to. EasyTalk supports configuring this at both the global and per-model level.
+
+### Why Use `$schema`?
+
+The `$schema` keyword:
+- Declares the JSON Schema version your schema is written against
+- Helps validators understand which specification to use
+- Enables tooling to provide appropriate validation and autocomplete
+- Documents the schema dialect for consumers of your API
+
+### Supported Draft Versions
+
+EasyTalk supports the following JSON Schema draft versions:
+
+| Symbol | JSON Schema Version | URI |
+|--------|---------------------|-----|
+| `:draft202012` | Draft 2020-12 (latest) | `https://json-schema.org/draft/2020-12/schema` |
+| `:draft201909` | Draft 2019-09 | `https://json-schema.org/draft/2019-09/schema` |
+| `:draft7` | Draft-07 | `http://json-schema.org/draft-07/schema#` |
+| `:draft6` | Draft-06 | `http://json-schema.org/draft-06/schema#` |
+| `:draft4` | Draft-04 | `http://json-schema.org/draft-04/schema#` |
+| `:none` | No `$schema` output (default) | N/A |
+
+### Global Configuration
+
+Configure the schema version globally to apply to all models:
+
+```ruby
+EasyTalk.configure do |config|
+  config.schema_version = :draft202012  # Use JSON Schema Draft 2020-12
+end
+```
+
+With this configuration, all models will include `$schema` in their output:
+
+```ruby
+class User
+  include EasyTalk::Model
+
+  define_schema do
+    property :name, String
+  end
+end
+
+User.json_schema
+# => {
+#      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+#      "type" => "object",
+#      "properties" => { "name" => { "type" => "string" } },
+#      "required" => ["name"],
+#      "additionalProperties" => false
+#    }
+```
+
+### Per-Model Configuration
+
+Override the global setting for individual models using the `schema_version` keyword in the schema definition:
+
+```ruby
+class LegacyModel
+  include EasyTalk::Model
+
+  define_schema do
+    schema_version :draft7  # Use Draft-07 for this specific model
+    property :name, String
+  end
+end
+
+LegacyModel.json_schema
+# => {
+#      "$schema" => "http://json-schema.org/draft-07/schema#",
+#      "type" => "object",
+#      ...
+#    }
+```
+
+### Disabling `$schema` for Specific Models
+
+If you have a global schema version configured but want to exclude `$schema` from a specific model, use `:none`:
+
+```ruby
+EasyTalk.configure do |config|
+  config.schema_version = :draft202012  # Global default
+end
+
+class InternalModel
+  include EasyTalk::Model
+
+  define_schema do
+    schema_version :none  # No $schema for this model
+    property :data, String
+  end
+end
+
+InternalModel.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => { "data" => { "type" => "string" } },
+#      ...
+#    }
+# Note: No "$schema" key present
+```
+
+### Custom Schema URIs
+
+You can also specify a custom URI if you're using a custom meta-schema or a different schema registry:
+
+```ruby
+class CustomModel
+  include EasyTalk::Model
+
+  define_schema do
+    schema_version 'https://my-company.com/schemas/v1/meta-schema.json'
+    property :id, String
+  end
+end
+```
+
+### Nested Models
+
+The `$schema` keyword only appears at the root level of the schema. When you have nested EasyTalk models, only the top-level model's `json_schema` output will include `$schema`:
+
+```ruby
+EasyTalk.configure do |config|
+  config.schema_version = :draft202012
+end
+
+class Address
+  include EasyTalk::Model
+  define_schema do
+    property :city, String
+  end
+end
+
+class User
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :address, Address
+  end
+end
+
+User.json_schema
+# => {
+#      "$schema" => "https://json-schema.org/draft/2020-12/schema",  # Only at root
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" },
+#        "address" => {
+#          "type" => "object",  # No $schema here
+#          "properties" => { "city" => { "type" => "string" } },
+#          ...
+#        }
+#      },
+#      ...
+#    }
+```
+
+### Default Behavior
+
+By default, `schema_version` is set to `:none`, meaning no `$schema` keyword is included in the generated schemas. This maintains backward compatibility with previous versions of EasyTalk.
+
+### Best Practices
+
+1. **Choose a version appropriate for your validators**: If you're using a specific JSON Schema validator, check which drafts it supports.
+
+2. **Use Draft 2020-12 for new projects**: It's the latest stable version with the most features.
+
+3. **Be consistent**: Use global configuration for consistency across your application, and only override per-model when necessary.
+
+4. **Consider your consumers**: If your schemas are consumed by external systems, ensure they support the draft version you're using.
+
+## Schema Identifier (`$id` Keyword)
+
+The `$id` keyword provides a unique identifier for your JSON Schema document. EasyTalk supports configuring this at both the global and per-model level.
+
+### Why Use `$id`?
+
+The `$id` keyword:
+- Establishes a unique URI identifier for the schema
+- Enables referencing schemas from other documents via `$ref`
+- Provides a base URI for resolving relative references within the schema
+- Documents the canonical location of the schema
+
+### Global Configuration
+
+Configure the schema ID globally to apply to all models:
+
+```ruby
+EasyTalk.configure do |config|
+  config.schema_id = 'https://example.com/schemas/base.json'
+end
+```
+
+With this configuration, all models will include `$id` in their output:
+
+```ruby
+class User
+  include EasyTalk::Model
+
+  define_schema do
+    property :name, String
+  end
+end
+
+User.json_schema
+# => {
+#      "$id" => "https://example.com/schemas/base.json",
+#      "type" => "object",
+#      "properties" => { "name" => { "type" => "string" } },
+#      "required" => ["name"],
+#      "additionalProperties" => false
+#    }
+```
+
+### Per-Model Configuration
+
+Override the global setting for individual models using the `schema_id` keyword in the schema definition:
+
+```ruby
+class User
+  include EasyTalk::Model
+
+  define_schema do
+    schema_id 'https://example.com/schemas/user.schema.json'
+    property :name, String
+    property :email, String
+  end
+end
+
+User.json_schema
+# => {
+#      "$id" => "https://example.com/schemas/user.schema.json",
+#      "type" => "object",
+#      ...
+#    }
+```
+
+### Disabling `$id` for Specific Models
+
+If you have a global schema ID configured but want to exclude `$id` from a specific model, use `:none`:
+
+```ruby
+EasyTalk.configure do |config|
+  config.schema_id = 'https://example.com/schemas/default.json'
+end
+
+class InternalModel
+  include EasyTalk::Model
+
+  define_schema do
+    schema_id :none  # No $id for this model
+    property :data, String
+  end
+end
+
+InternalModel.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => { "data" => { "type" => "string" } },
+#      ...
+#    }
+# Note: No "$id" key present
+```
+
+### Combining `$schema` and `$id`
+
+When both `$schema` and `$id` are configured, they appear in the standard order (`$schema` first, then `$id`):
+
+```ruby
+class Product
+  include EasyTalk::Model
+
+  define_schema do
+    schema_version :draft202012
+    schema_id 'https://example.com/schemas/product.schema.json'
+    property :name, String
+    property :price, Float
+  end
+end
+
+Product.json_schema
+# => {
+#      "$schema" => "https://json-schema.org/draft/2020-12/schema",
+#      "$id" => "https://example.com/schemas/product.schema.json",
+#      "type" => "object",
+#      ...
+#    }
+```
+
+### Nested Models
+
+The `$id` keyword only appears at the root level of the schema. When you have nested EasyTalk models, only the top-level model's `json_schema` output will include `$id`:
+
+```ruby
+EasyTalk.configure do |config|
+  config.schema_id = 'https://example.com/schemas/user.json'
+end
+
+class Address
+  include EasyTalk::Model
+  define_schema do
+    property :city, String
+  end
+end
+
+class User
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :address, Address
+  end
+end
+
+User.json_schema
+# => {
+#      "$id" => "https://example.com/schemas/user.json",  # Only at root
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" },
+#        "address" => {
+#          "type" => "object",  # No $id here
+#          "properties" => { "city" => { "type" => "string" } },
+#          ...
+#        }
+#      },
+#      ...
+#    }
+```
+
+### URI Formats
+
+The `$id` accepts various URI formats:
+
+```ruby
+# Absolute URI (recommended for published schemas)
+schema_id 'https://example.com/schemas/user.schema.json'
+
+# Relative URI
+schema_id 'user.schema.json'
+
+# URN format
+schema_id 'urn:example:user-schema'
+```
+
+### Default Behavior
+
+By default, `schema_id` is set to `nil`, meaning no `$id` keyword is included in the generated schemas. This maintains backward compatibility with previous versions of EasyTalk.
+
+### Best Practices
+
+1. **Use absolute URIs for published schemas**: This ensures global uniqueness and enables external references.
+
+2. **Follow a consistent naming convention**: For example, `https://yourdomain.com/schemas/{model-name}.schema.json`.
+
+3. **Keep IDs stable**: Once published, avoid changing schema IDs as external systems may reference them.
+
+4. **Combine with `$schema`**: When publishing schemas, include both `$schema` (for validation) and `$id` (for identification).
+
+## Schema References (`$ref` and `$defs`)
+
+The `$ref` keyword allows you to reference reusable schema definitions, reducing duplication when the same model is used in multiple places. EasyTalk supports automatic `$ref` generation for nested models.
+
+### Why Use `$ref`?
+
+The `$ref` keyword:
+- Reduces schema duplication when the same model appears multiple times
+- Produces cleaner, more organized schemas
+- Improves schema readability and maintainability
+- Aligns with JSON Schema best practices for reusable definitions
+
+### Default Behavior (Inline Schemas)
+
+By default, EasyTalk inlines nested model schemas directly:
+
+```ruby
+class Address
+  include EasyTalk::Model
+  define_schema do
+    property :street, String
+    property :city, String
+  end
+end
+
+class Person
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :address, Address
+  end
+end
+
+Person.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" },
+#        "address" => {
+#          "type" => "object",
+#          "properties" => {
+#            "street" => { "type" => "string" },
+#            "city" => { "type" => "string" }
+#          },
+#          ...
+#        }
+#      },
+#      ...
+#    }
+```
+
+### Enabling `$ref` References
+
+#### Global Configuration
+
+Enable `$ref` generation for all nested models:
+
+```ruby
+EasyTalk.configure do |config|
+  config.use_refs = true
+end
+```
+
+With this configuration, nested models are referenced via `$ref` and their definitions are placed in `$defs`:
+
+```ruby
+Person.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" },
+#        "address" => { "$ref" => "#/$defs/Address" }
+#      },
+#      "$defs" => {
+#        "Address" => {
+#          "type" => "object",
+#          "properties" => {
+#            "street" => { "type" => "string" },
+#            "city" => { "type" => "string" }
+#          },
+#          ...
+#        }
+#      },
+#      ...
+#    }
+```
+
+#### Per-Property Configuration
+
+You can also enable `$ref` for specific properties using the `ref: true` constraint:
+
+```ruby
+class Person
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :address, Address, ref: true  # Use $ref for this property
+  end
+end
+```
+
+Or disable `$ref` for specific properties when it's enabled globally:
+
+```ruby
+EasyTalk.configure do |config|
+  config.use_refs = true
+end
+
+class Person
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :address, Address, ref: false  # Inline this property despite global setting
+  end
+end
+```
+
+### Arrays of Models
+
+When using `$ref` with arrays of models, the `$ref` applies to the array items:
+
+```ruby
+EasyTalk.configure do |config|
+  config.use_refs = true
+end
+
+class Company
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :addresses, T::Array[Address]
+  end
+end
+
+Company.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" },
+#        "addresses" => {
+#          "type" => "array",
+#          "items" => { "$ref" => "#/$defs/Address" }
+#        }
+#      },
+#      "$defs" => {
+#        "Address" => { ... }
+#      },
+#      ...
+#    }
+```
+
+You can also use the per-property `ref` constraint with arrays:
+
+```ruby
+property :addresses, T::Array[Address], ref: true
+```
+
+### Nilable Models with `$ref`
+
+When using `$ref` with nilable model types, EasyTalk uses `anyOf` to combine the reference with the null type:
+
+```ruby
+EasyTalk.configure do |config|
+  config.use_refs = true
+end
+
+class Person
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :address, T.nilable(Address)
+  end
+end
+
+Person.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" },
+#        "address" => {
+#          "anyOf" => [
+#            { "$ref" => "#/$defs/Address" },
+#            { "type" => "null" }
+#          ]
+#        }
+#      },
+#      "$defs" => {
+#        "Address" => { ... }
+#      },
+#      ...
+#    }
+```
+
+### Multiple References to the Same Model
+
+When the same model is used multiple times, it only appears once in `$defs`:
+
+```ruby
+class Person
+  include EasyTalk::Model
+  define_schema do
+    property :name, String
+    property :home_address, Address, ref: true
+    property :work_address, Address, ref: true
+    property :shipping_addresses, T::Array[Address], ref: true
+  end
+end
+
+Person.json_schema
+# => {
+#      "type" => "object",
+#      "properties" => {
+#        "name" => { "type" => "string" },
+#        "home_address" => { "$ref" => "#/$defs/Address" },
+#        "work_address" => { "$ref" => "#/$defs/Address" },
+#        "shipping_addresses" => {
+#          "type" => "array",
+#          "items" => { "$ref" => "#/$defs/Address" }
+#        }
+#      },
+#      "$defs" => {
+#        "Address" => { ... }  # Only defined once
+#      },
+#      ...
+#    }
+```
+
+### Combining `$ref` with Other Constraints
+
+You can add additional constraints alongside `$ref`:
+
+```ruby
+class Person
+  include EasyTalk::Model
+  define_schema do
+    property :address, Address, ref: true, description: "Primary address", title: "Main Address"
+  end
+end
+
+Person.json_schema["properties"]["address"]
+# => {
+#      "$ref" => "#/$defs/Address",
+#      "description" => "Primary address",
+#      "title" => "Main Address"
+#    }
+```
+
+### Interaction with `compose`
+
+When using `compose` with `T::AllOf`, `T::AnyOf`, or `T::OneOf`, the composed models are also placed in `$defs`:
+
+```ruby
+class Employee
+  include EasyTalk::Model
+  define_schema do
+    compose T::AllOf[Person, EmployeeDetails]
+    property :badge_number, String
+  end
+end
+```
+
+If you also have properties using `$ref`, both the composed models and property models will appear in `$defs`.
+
+### Best Practices
+
+1. **Use global configuration for consistency**: If you prefer `$ref` style, enable it globally rather than per-property.
+
+2. **Consider schema consumers**: Some JSON Schema validators and tools work better with inlined schemas, while others prefer `$ref`. Choose based on your use case.
+
+3. **Use `$ref` for frequently reused models**: If a model appears in many places, `$ref` reduces schema size and improves maintainability.
+
+4. **Keep inline for simple, single-use models**: For models used only once, inlining may be more readable.
+
+### Default Behavior
+
+By default, `use_refs` is set to `false`, meaning nested models are inlined. This maintains backward compatibility with previous versions of EasyTalk.
+
 ## JSON Schema Compatibility
 
 ### Supported Versions
-EasyTalk is currently loose about JSON Schema versions. It doesn't strictly enforce or adhere to any particular version of the specification. The goal is to add more robust support for the latest JSON Schema specs in the future.
+EasyTalk supports generating schemas compatible with JSON Schema Draft-04 through Draft 2020-12. Use the `schema_version` configuration option to declare which version your schemas conform to (see [JSON Schema Version](#json-schema-version-schema-keyword) above).
+
+While EasyTalk allows you to specify any draft version via the `$schema` keyword, the generated schema structure is generally compatible across versions. Some newer draft features may require manual adjustment.
 
 ### Specification Compliance
 To learn about current capabilities, see the [spec/easy_talk/examples](https://github.com/sergiobayona/easy_talk/tree/main/spec/easy_talk/examples) folder. The examples illustrate how EasyTalk generates JSON Schema in different scenarios.
 
 ### Known Limitations
 - Limited support for custom formats
-- No direct support for JSON Schema draft 2020-12 features
+- Some draft-specific keywords may not be supported
 - Complex composition scenarios may require manual adjustment
 
 ## License