easy_talk 3.3.0 → 3.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f11b7be6e0fa32087d5be57be3d3e37d5bd5b96cc61ae8626b33d41a420e401
-  data.tar.gz: 82ba98f220e8e75e3bb3e208a595a168f188c226a130e88f13991da9a386cfc6
+  metadata.gz: b571b59c30a196b82285a7fa67c275002cb9f4bc6a07a0e0c70cc69d04d60b50
+  data.tar.gz: 599c489167248facc490dbc3add9c0fddb005b9aab654d919e0377a1ae2352af
 SHA512:
-  metadata.gz: 90fb93ef486adb8151e883e6929437be2f52bdbe4a51bb45485006884a983b80ce9f10de1d14b313031be4b8126d6fe21c3bd54a998863543a1be1d752c124d9
-  data.tar.gz: 2ff9102ba57ae6738cb79511fdd095b5f798a760c009b10d2b5577c30575f04d94dfb11e410036e566971d92e27e2c4bc2d17336e44c64f9d35b966bbe1b4960
+  metadata.gz: 8f27233da948ebf61071d179f8b8b1031df4ffa262bd9050488aa09e82e462d8c8a52b25290b8af1965c7c23f39c73a43c8b95972ac3d388aea645c50d7754c9
+  data.tar.gz: 8cba0f544c9746674f15005232c714d385a3e407c3add6d4089eb2260a1a6889a0e7a0160283d42fdc388f91c26ac96c52d8fae8147458821cd346bde2c60651

data/CHANGELOG.md

@@ -1,3 +1,44 @@
+## [3.3.2] - 2026-03-09
+
+### Fixed
+
+- **Schema Cache Corruption**: Fixed schema cache corruption when nested models have constraints (#163)
+- **Mutable Default Values (Model)**: Fixed mutable default values (arrays, hashes) being shared across `EasyTalk::Model` instances (#165)
+- **Nilable Properties Rejecting Nil**: Fixed nilable properties incorrectly rejecting `nil` in ActiveModel validations (#166)
+- **Nested Model Blank False Positive**: Fixed nested model blank false positive in `apply_object_validations` (#167)
+- **Nilable Boolean Validation**: Fixed `T.nilable(T::Boolean)` rejecting `nil` in ActiveModel validations (#168)
+- **Schema False Value Discard**: Fixed `EasyTalk::Schema` silently discarding `false` values on initialization (#169)
+- **Mutable Default Values (Schema)**: Fixed mutable default values shared across `EasyTalk::Schema` instances (#170)
+- **Double-Call Stale Schema**: Fixed `define_schema` double-call leaving stale schema and validators (#171)
+- **Incorrect Fallback String**: Fixed incorrect fallback string in type introspection for composition types (#175)
+- **Optional Array Nil Rejection**: Fixed optional array properties incorrectly rejecting `nil` (#177)
+
+### Added
+
+- **Option Validation for UnionBuilder and NullBuilder**: Added constraint option validation to `UnionBuilder` and `NullBuilder`, raising errors on unsupported options (#176)
+
+### Internal
+
+- **SchemaBase Extraction**: Extracted `SchemaBase` module to eliminate duplication between `Model` and `Schema` (#172)
+- **Type Introspection Consolidation**: Consolidated type introspection logic into the `TypeIntrospection` module, removing duplicate checks from adapters and helpers (#173, #174)
+- **Test Suite Consolidation**: Consolidated standalone bug-fix specs into the regular test suite for better organization
+
+## [3.3.1] - 2026-02-03
+
+### Added
+
+- **RubyLLM Compatibility Extension**: Seamless integration between EasyTalk models and RubyLLM's tool and structured output features (#122)
+  - New `RubyLLMCompatibility` module adds class method `to_json_schema` for `with_schema` support
+  - New `RubyLLMToolOverrides` module for classes inheriting from `RubyLLM::Tool`
+  - Overrides `description` and `params_schema` methods to use EasyTalk schema definitions
+  - Automatically included when using `EasyTalk::Model`
+  - Tools inherit from `RubyLLM::Tool` directly, gaining full access to features like `halt`, `call`, `provider_params`
+  - New example files: `examples/ruby_llm/tools_integration.rb`, `examples/ruby_llm/structured_output.rb`
+
+### Changed
+
+- **Documentation**: Updated README with improved examples and documentation
+
 ## [3.3.0] - 2026-01-12
 
 ### Added

data/README.md

@@ -52,13 +52,43 @@ EasyTalk makes the schema definition the single source of truth, so you can:
   - **RFC 7807** problem details
   - **JSON:API** error objects
 
-- **LLM tool/function schemas without a second schema layer**  
-  Use the same contract to generate JSON Schema for function/tool calling.
+- **LLM tool/function schemas without a second schema layer**
+  Use the same contract to generate JSON Schema for function/tool calling. See [RubyLLM Integration](#rubyllm-integration).
 
 EasyTalk is for teams who want their data contracts to be **correct, reusable, and boring** (the good kind of boring).
 
 ---
 
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Property constraints](#property-constraints)
+- [Core concepts](#core-concepts)
+  - [Required vs optional vs nullable](#required-vs-optional-vs-nullable-dont-get-tricked)
+  - [Nested models](#nested-models-and-automatic-instantiation)
+  - [Tuple arrays](#tuple-arrays-fixed-position-types)
+  - [Composition (AnyOf / OneOf / AllOf)](#composition-anyof--oneof--allof)
+- [Validations](#validations)
+  - [Automatic validations](#automatic-validations-default)
+  - [Per-model validation control](#per-model-validation-control)
+  - [Per-property validation control](#per-property-validation-control)
+  - [Validation adapters](#validation-adapters)
+- [Error formatting](#error-formatting)
+- [Schema-only mode](#schema-only-mode)
+- [RubyLLM Integration](#rubyllm-integration)
+- [Configuration highlights](#configuration-highlights)
+- [Advanced topics](#advanced-topics)
+  - [JSON Schema drafts, `$id`, and `$ref`](#json-schema-drafts-id-and-ref)
+  - [Additional properties with types](#additional-properties-with-types)
+  - [Object-level constraints](#object-level-constraints)
+  - [Custom type builders](#custom-type-builders)
+- [Known limitations](#known-limitations)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
 ## Installation
 
 ### Requirements
@@ -80,6 +110,14 @@ bundle install
 
 ## Quick start
 
+<table>
+<tr>
+<th>EasyTalk Model</th>
+<th>Generated JSON Schema</th>
+</tr>
+<tr>
+<td>
+
 ```ruby
 require "easy_talk"
 
@@ -96,14 +134,10 @@ class User
     property :age, Integer, minimum: 18
   end
 end
-
-User.json_schema   # => Ruby Hash (JSON Schema)
-user = User.new(name: "A")  # invalid: min_length is 2
-user.valid?        # => false
-user.errors        # => ActiveModel::Errors
 ```
 
-**Generated JSON Schema:**
+</td>
+<td>
 
 ```json
 {
@@ -120,6 +154,17 @@ user.errors        # => ActiveModel::Errors
 }
 ```
 
+</td>
+</tr>
+</table>
+
+```ruby
+User.json_schema   # => Ruby Hash (JSON Schema)
+user = User.new(name: "A")  # invalid: min_length is 2
+user.valid?        # => false
+user.errors        # => ActiveModel::Errors
+```
+
 ---
 
 ## Property constraints
@@ -240,6 +285,14 @@ end
 
 Use `T::Tuple` for arrays where each position has a specific type (e.g., coordinates, CSV rows, database records):
 
+<table>
+<tr>
+<th>EasyTalk Model</th>
+<th>Generated JSON Schema</th>
+</tr>
+<tr>
+<td>
+
 ```ruby
 class GeoLocation
   include EasyTalk::Model
@@ -257,7 +310,8 @@ location = GeoLocation.new(
 )
 ```
 
-**Generated JSON Schema:**
+</td>
+<td>
 
 ```json
 {
@@ -273,6 +327,10 @@ location = GeoLocation.new(
 }
 ```
 
+</td>
+</tr>
+</table>
+
 **Mixed-type tuples:**
 
 ```ruby
@@ -469,6 +527,66 @@ Use this for documentation, OpenAPI generation, or when validation happens elsew
 
 ---
 
+## RubyLLM Integration
+
+EasyTalk integrates seamlessly with [RubyLLM](https://github.com/crmne/ruby_llm) for structured outputs and tool definitions.
+
+### Structured Outputs
+
+Use any EasyTalk model with RubyLLM's `with_schema` to get structured JSON responses:
+
+```ruby
+class Recipe
+  include EasyTalk::Model
+
+  define_schema do
+    description "A cooking recipe"
+    property :name, String, description: "Name of the dish"
+    property :ingredients, T::Array[String], description: "List of ingredients"
+    property :prep_time_minutes, Integer, description: "Preparation time in minutes"
+  end
+end
+
+chat = RubyLLM.chat.with_schema(Recipe)
+response = chat.ask("Give me a simple pasta recipe")
+
+# RubyLLM returns parsed JSON - instantiate with EasyTalk model
+recipe = Recipe.new(response.content)
+recipe.name           # => "Spaghetti Aglio e Olio"
+recipe.ingredients    # => ["spaghetti", "garlic", "olive oil", ...]
+```
+
+### Tools
+
+Create LLM tools by inheriting from `RubyLLM::Tool` and including `EasyTalk::Model`:
+
+```ruby
+class Weather < RubyLLM::Tool
+  include EasyTalk::Model
+
+  define_schema do
+    description 'Gets current weather for a location'
+    property :latitude, String, description: 'Latitude (e.g., 52.5200)'
+    property :longitude, String, description: 'Longitude (e.g., 13.4050)'
+  end
+
+  def execute(latitude:, longitude:)
+    # Fetch weather data from API...
+    { temperature: 22, conditions: "sunny" }
+  end
+end
+
+chat = RubyLLM.chat.with_tool(Weather)
+response = chat.ask("What's the weather in Berlin?")
+```
+
+This pattern gives you:
+- Full access to `RubyLLM::Tool` features (`halt`, `call`, etc.)
+- EasyTalk's schema DSL for parameter definitions
+- Automatic JSON Schema generation for the LLM
+
+---
+
 ## Configuration highlights
 
 ```ruby
@@ -517,6 +635,14 @@ end
 
 Use external URIs in `$ref` for modular, reusable schemas:
 
+<table>
+<tr>
+<th>EasyTalk Model</th>
+<th>Generated JSON Schema</th>
+</tr>
+<tr>
+<td>
+
 ```ruby
 EasyTalk.configure do |config|
   config.use_refs = true
@@ -544,20 +670,34 @@ class Customer
 end
 
 Customer.json_schema
-# =>
-# {
-#   "properties": {
-#     "address": { "$ref": "https://example.com/schemas/address" }
-#   },
-#   "$defs": {
-#     "Address": {
-#       "$id": "https://example.com/schemas/address",
-#       "properties": { "street": {...}, "city": {...} }
-#     }
-#   }
-# }
 ```
 
+</td>
+<td>
+
+```json
+{
+  "properties": {
+    "address": {
+      "$ref": "https://example.com/schemas/address"
+    }
+  },
+  "$defs": {
+    "Address": {
+      "$id": "https://example.com/schemas/address",
+      "properties": {
+        "street": { "type": "string" },
+        "city": { "type": "string" }
+      }
+    }
+  }
+}
+```
+
+</td>
+</tr>
+</table>
+
 **Explicit schema IDs:**
 
 ```ruby
@@ -608,6 +748,14 @@ config.as_json
 
 **With constraints:**
 
+<table>
+<tr>
+<th>EasyTalk Model</th>
+<th>Generated JSON Schema</th>
+</tr>
+<tr>
+<td>
+
 ```ruby
 class StrictConfig
   include EasyTalk::Model
@@ -615,22 +763,34 @@ class StrictConfig
   define_schema do
     property :id, Integer
     # Integer values between 0 and 100 only
-    additional_properties Integer, minimum: 0, maximum: 100
+    additional_properties Integer,
+      minimum: 0, maximum: 100
   end
 end
 
 StrictConfig.json_schema
-# =>
-# {
-#   "properties": { "id": { "type": "integer" } },
-#   "additionalProperties": {
-#     "type": "integer",
-#     "minimum": 0,
-#     "maximum": 100
-#   }
-# }
 ```
 
+</td>
+<td>
+
+```json
+{
+  "properties": {
+    "id": { "type": "integer" }
+  },
+  "additionalProperties": {
+    "type": "integer",
+    "minimum": 0,
+    "maximum": 100
+  }
+}
+```
+
+</td>
+</tr>
+</table>
+
 **Nested models as additional properties:**
 
 ```ruby

data/easy_talk.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/easy_talk/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'easy_talk'
+  spec.version = EasyTalk::VERSION
+  spec.authors = ['Sergio Bayona']
+  spec.email = ['bayona.sergio@gmail.com']
+
+  spec.summary = 'JSON Schema generation and validation for Ruby classes, ideal for LLM function calling.'
+  spec.description = 'Define schemas using a clean DSL and get both JSON Schema documents and runtime validations. ' \
+                     'Perfect for API request/response validation, LLM function definitions (OpenAI, Anthropic), ' \
+                     'and structured data modeling. Features Sorbet-style types, schema composition, ' \
+                     'pluggable validation adapters, and multiple error output formats (JSON:API, RFC 7807).'
+  spec.homepage = 'https://github.com/sergiobayona/easy_talk'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.2'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = 'https://github.com/sergiobayona/easy_talk/blob/main/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ spec/ .git .github Gemfile])
+    end
+  end
+
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activemodel', ['>= 7.0', '< 9.0']
+  spec.add_dependency 'activesupport', ['>= 7.0', '< 9.0']
+  spec.add_dependency 'js_regex', '~> 3.0'
+  spec.add_dependency 'sorbet-runtime', '~> 0.5'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/examples/ruby_llm/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# EasyTalk from the parent directory
+gem 'easy_talk', path: '../..'
+
+# RubyLLM for LLM interactions
+gem 'ruby_llm'
+
+# HTTP client for API calls (used in tools example)
+gem 'faraday'

data/examples/ruby_llm/structured_output.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ruby_llm'
+require 'easy_talk'
+
+# Example: Structured Outputs
+# Demonstrates using EasyTalk models to generate structured JSON responses.
+
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
+end
+
+# 1. Define the Schema using EasyTalk
+class Recipe
+  include EasyTalk::Model
+
+  define_schema do
+    description "A simple cooking recipe"
+    property :name, String, description: "Name of the dish"
+    property :ingredients, T::Array[String], description: "List of ingredients"
+    property :prep_time_minutes, Integer, description: "Preparation time in minutes"
+    property :steps, T::Array[String], description: "Step by step cooking instructions"
+  end
+end
+
+puts "--- Structured Output Example ---"
+
+# 2. Use the EasyTalk model as the output schema
+# RubyLLM uses the schema to force the LLM to reply with a matching JSON structure.
+# Our compatibility layer ensures 'Recipe' responds to to_json_schema as RubyLLM expects.
+chat = RubyLLM.chat.with_schema(Recipe)
+
+puts "User: Give me a simple spaghetti carbonara recipe."
+response = chat.ask "Give me a simple spaghetti carbonara recipe."
+
+# 3. Access the structured data
+# RubyLLM returns parsed JSON as a Hash, so we instantiate the model with it
+recipe = Recipe.new(response.content)
+
+puts "\nGenerated Recipe:"
+puts "Name: #{recipe.name}"
+puts "Time: #{recipe.prep_time_minutes} mins"
+puts "Ingredients:"
+recipe.ingredients.each { |ing| puts "- #{ing}" }
+puts "Steps:"
+recipe.steps.each_with_index { |step, i| puts "#{i + 1}. #{step}" }

data/examples/ruby_llm/tools_integration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ruby_llm'
+require 'easy_talk'
+require 'faraday'
+
+# Example: Tools Integration
+# Demonstrates using EasyTalk models as Tools for RubyLLM.
+#
+# To create a tool, inherit from RubyLLM::Tool and include EasyTalk::Model.
+# This gives you:
+# - Full access to RubyLLM::Tool features like halt()
+# - EasyTalk's schema DSL for defining parameters
+# - Automatic integration with RubyLLM's with_tool method
+
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV.fetch('OPENAI_API_KEY', nil)
+end
+
+class Weather < RubyLLM::Tool
+  include EasyTalk::Model
+
+  define_schema do
+    description 'Gets current weather for a location'
+    property :latitude, String, description: 'Latitude (e.g., 52.5200)'
+    property :longitude, String, description: 'Longitude (e.g., 13.4050)'
+  end
+
+  def execute(latitude:, longitude:)
+    puts "Executing Weather Tool for #{latitude}, #{longitude}"
+    url = "https://api.open-meteo.com/v1/forecast?latitude=#{latitude}&longitude=#{longitude}&current=temperature_2m,wind_speed_10m"
+    response = Faraday.get(url)
+    data = JSON.parse(response.body)
+    data.to_s
+  rescue StandardError => e
+    { error: e.message }
+  end
+end
+
+puts '--- Tools Integration Example ---'
+puts
+
+chat = RubyLLM.chat.with_tool(Weather)
+
+puts 'User: What is the weather in Berlin (Lat: 52.52, Long: 13.405)?'
+response = chat.ask 'What is the weather in Berlin (Lat: 52.52, Long: 13.405)?'
+
+puts "Assistant: #{response.content}"

data/lib/easy_talk/builders/composition_builder.rb

@@ -17,6 +17,8 @@ module EasyTalk
         'OneOfBuilder' => 'oneOf'
       }.freeze
 
+      VALID_OPTIONS = %i[title description optional as validate ref].freeze
+
       sig { params(name: Symbol, type: T.untyped, constraints: T::Hash[Symbol, T.untyped]).void }
       # Initializes a new instance of the CompositionBuilder class.
       #
@@ -24,6 +26,7 @@ module EasyTalk
       # @param type [Class] The type of the composition.
       # @param constraints [Hash] The constraints for the composition.
       def initialize(name, type, constraints)
+        EasyTalk.assert_valid_property_options(name, constraints, VALID_OPTIONS)
         @composer_type = self.class.name.split('::').last
         @name = name
         @type = type

data/lib/easy_talk/builders/null_builder.rb

@@ -9,10 +9,12 @@ module EasyTalk
     class NullBuilder < BaseBuilder
       extend T::Sig
 
+      VALID_OPTIONS = {}.freeze
+
       # Initializes a new instance of the NullBuilder class.
-      sig { params(name: Symbol, _constraints: T::Hash[Symbol, T.untyped]).void }
-      def initialize(name, _constraints = {})
-        super(name, { type: 'null' }, {}, {})
+      sig { params(name: Symbol, constraints: T::Hash[Symbol, T.untyped]).void }
+      def initialize(name, constraints = {})
+        super(name, { type: 'null' }, constraints, VALID_OPTIONS)
       end
     end
   end

data/lib/easy_talk/builders/object_builder.rb

@@ -41,7 +41,7 @@ module EasyTalk
         # Keep a reference to the original schema definition
         @schema_definition = schema_definition
         # Deep duplicate the raw schema hash so we can mutate it safely
-        @original_schema = deep_dup(schema_definition.schema)
+        @original_schema = EasyTalk.deep_dup(schema_definition.schema)
 
         # We'll collect required property names in this Set
         @required_properties = Set.new
@@ -71,24 +71,6 @@ module EasyTalk
 
       private
 
-      ##
-      # Deep duplicates a hash, including nested hashes.
-      # This prevents mutations from leaking back to the original schema.
-      #
-      def deep_dup(obj)
-        case obj
-        when Hash
-          obj.transform_values { |v| deep_dup(v) }
-        when Array
-          obj.map { |v| deep_dup(v) }
-        when Class, Module
-          # Don't duplicate Class or Module objects - they represent types
-          obj
-        else
-          obj.duplicable? ? obj.dup : obj
-        end
-      end
-
       ##
       # Main aggregator: merges the top-level schema keys (like :properties, :subschemas)
       # into a single hash that we'll feed to BaseBuilder.
@@ -250,7 +232,7 @@ module EasyTalk
         elsif prop_type.is_a?(EasyTalk::Types::Composer)
           collect_ref_models(prop_type.items, constraints)
         # Handle typed arrays with EasyTalk model items
-        elsif typed_array?(prop_type)
+        elsif TypeIntrospection.typed_array?(prop_type)
           extract_inner_types(prop_type).each { |inner_type| collect_ref_models(inner_type, constraints) }
         # Handle nilable types
         elsif nilable_with_model?(prop_type)
@@ -272,12 +254,8 @@ module EasyTalk
         EasyTalk.configuration.use_refs
       end
 
-      def typed_array?(prop_type)
-        prop_type.is_a?(T::Types::TypedArray)
-      end
-
       def extract_inner_types(prop_type)
-        return [] unless typed_array?(prop_type)
+        return [] unless TypeIntrospection.typed_array?(prop_type)
 
         if prop_type.type.is_a?(EasyTalk::Types::Composer)
           prop_type.type.items
@@ -302,9 +280,7 @@ module EasyTalk
       # Adds $defs entries for all collected ref models.
       #
       def add_ref_model_defs(schema_hash)
-        definitions = @ref_models.each_with_object({}) do |model, acc|
-          acc[model.name] = model.schema
-        end
+        definitions = @ref_models.to_h { |model| [model.name, EasyTalk.deep_dup(model.schema)] }
 
         existing_defs = schema_hash[:defs] || {}
         schema_hash[:defs] = existing_defs.merge(definitions)
@@ -327,9 +303,7 @@ module EasyTalk
       #
       def add_defs_from_subschema(schema_hash, subschema)
         # Build up a hash of class_name => schema for each sub-item
-        definitions = subschema.items.each_with_object({}) do |item, acc|
-          acc[item.name] = item.schema
-        end
+        definitions = subschema.items.to_h { |item| [item.name, EasyTalk.deep_dup(item.schema)] }
         # Merge or create :defs
         existing_defs = schema_hash[:defs] || {}
         schema_hash[:defs] = existing_defs.merge(definitions)

data/lib/easy_talk/builders/union_builder.rb

@@ -10,8 +10,11 @@ module EasyTalk
       extend CollectionHelpers
       extend T::Sig
 
+      VALID_OPTIONS = %i[title description optional as validate].freeze
+
       sig { params(name: Symbol, type: T.untyped, constraints: T::Hash[Symbol, T.untyped]).void }
       def initialize(name, type, constraints)
+        EasyTalk.assert_valid_property_options(name, constraints, VALID_OPTIONS)
         @name = name
         @type = type
         @constraints = constraints

data/lib/easy_talk/errors_helper.rb

@@ -25,7 +25,7 @@ module EasyTalk
       raise UnknownOptionError, message
     end
 
-    def self.extract_inner_type(type_info)
+    def self.extract_element_type(type_info)
       # No change needed here
       if type_info.respond_to?(:type) && type_info.type.respond_to?(:raw_type)
         type_info.type.raw_type
@@ -49,7 +49,7 @@ module EasyTalk
     def self.validate_typed_array_values(property_name:, constraint_name:, type_info:, array_value:)
       # Raise error if value is not an array but type expects one
       unless array_value.is_a?(Array)
-        inner_type = extract_inner_type(type_info)
+        inner_type = extract_element_type(type_info)
         expected_desc = TypeIntrospection.boolean_type?(inner_type) ? 'Boolean (true or false)' : inner_type.to_s
         raise_constraint_error(
           property_name: property_name,
@@ -59,7 +59,7 @@ module EasyTalk
         )
       end
 
-      inner_type = extract_inner_type(type_info)
+      inner_type = extract_element_type(type_info)
       array_value.each_with_index do |element, index|
         validate_array_element(
           property_name: property_name,
@@ -153,7 +153,7 @@ module EasyTalk
       # Handle Sorbet type objects
       elsif value_type.class.ancestors.include?(T::Types::Base)
         # Extract the inner type
-        inner_type = extract_inner_type(value_type)
+        inner_type = extract_element_type(value_type)
 
         if inner_type.is_a?(Array)
           # For union types, check if the value matches any of the allowed types