Simplify

Author: danielfriis

lib/ruby_llm/schema.rb

@@ -62,21 +62,9 @@ def valid?
       end
     end
 
-    def self.new(*args, **kwargs, &block)
-      # Only return the class itself when called within a schema block context for embedding
-      # This is determined by checking if we're being called with no arguments in a specific context
-      if args.empty? && kwargs.empty? && block.nil? && caller.any? { |line| line.include?("class_eval") }
-        self
-      else
-        instance = allocate
-        instance.send(:initialize, *args, **kwargs)
-        instance
-      end
-    end
-
-    def initialize(name = nil, description: nil, **kwargs)
+    def initialize(name = nil, description: nil)
       @name = name || self.class.name || "Schema"
-      @description = description || kwargs[:description]
+      @description = description
     end
 
     def validate!

lib/ruby_llm/schema/dsl/schema_builders.rb

@@ -54,7 +54,7 @@ def object_schema(description: nil, of: nil, &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 instance, convert it to reference
+            # 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} : {})
             else

lib/ruby_llm/schema/dsl/utilities.rb

@@ -38,7 +38,7 @@ def determine_array_items(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, or a Schema class."
+          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)
@@ -52,7 +52,11 @@ def determine_object_reference(of, description = nil)
               raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Class must inherit from RubyLLM::Schema."
             end
           else
-            raise InvalidObjectTypeError, "Invalid object type: #{of.inspect}. Must be a symbol reference or a Schema class."
+            if 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."
+            end
           end
 
           description ? result.merge(description: description) : result
@@ -87,18 +91,31 @@ def primitive_type?(type)
         end
 
         def schema_class?(type)
-          type.is_a?(Class) && type < Schema
+          (type.is_a?(Class) && type < Schema) || type.is_a?(Schema)
         end
 
-        def schema_class_to_inline_schema(schema_class)
+        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|
-            schema[:description] = schema_class.description if schema_class.description
+            # 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

spec/ruby_llm/schema_spec.rb

@@ -409,11 +409,11 @@
       # Invalid object types
       expect {
         schema_class.object :item, of: 123
-      }.to raise_error(RubyLLM::Schema::InvalidObjectTypeError, /Invalid object type: 123.*Must be a symbol reference or a Schema class/)
+      }.to raise_error(RubyLLM::Schema::InvalidObjectTypeError, /Invalid object type: 123.*Must be a symbol reference, a Schema class, or a Schema instance/)
 
       expect {
         schema_class.object :item, of: "invalid"
-      }.to raise_error(RubyLLM::Schema::InvalidObjectTypeError, /Invalid object type: "invalid".*Must be a symbol reference or a Schema class/)
+      }.to raise_error(RubyLLM::Schema::InvalidObjectTypeError, /Invalid object type: "invalid".*Must be a symbol reference, a Schema class, or a Schema instance/)
 
       # Non-Schema class
       expect {