Lots of work

Author: danielfriis

example_inline_schemas.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "lib/ruby_llm/schema"
+
+# Define reusable schema classes
+class PersonSchema < RubyLLM::Schema
+  string :name, description: "Person's full name"
+  integer :age, description: "Person's age"
+end
+
+class AddressSchema < RubyLLM::Schema
+  string :street, description: "Street address"
+  string :city, description: "City name"
+  string :zipcode, description: "Postal code"
+end
+
+# Define a CompanySchema using inline schema insertion
+class CompanySchema < RubyLLM::Schema
+  string :name, description: "Company name"
+
+  # Arrays with inline schema insertion
+  array :employees, of: PersonSchema, description: "Company employees"
+
+  # Objects with inline schema insertion
+  object :founder, of: PersonSchema, description: "Company founder"
+  object :headquarters, of: AddressSchema, description: "Main office"
+
+  # Mixed usage - Schema.new in blocks still works
+  object :ceo do
+    PersonSchema.new
+  end
+
+  # Users can still use explicit definitions when they want shared references
+  define :department do
+    string :name
+    integer :employee_count
+  end
+
+  array :departments, of: :department, description: "Company departments"
+end
+
+# Generate and display the JSON schema
+company = CompanySchema.new("CompanyExample")
+json_output = company.to_json_schema
+
+puts "=== Inline Schema Example ==="
+puts "Notice how PersonSchema and AddressSchema are embedded directly where used,"
+puts "while :department uses a shared definition.\n\n"
+
+puts JSON.pretty_generate(json_output)

lib/ruby_llm/schema.rb

@@ -62,9 +62,21 @@ def valid?
       end
     end
 
-    def initialize(name = nil, description: nil)
+    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)
       @name = name || self.class.name || "Schema"
-      @description = description
+      @description = description || kwargs[:description]
     end
 
     def validate!

lib/ruby_llm/schema/dsl/schema_builders.rb

@@ -44,16 +44,19 @@ def null_schema(description: nil)
           {type: "null", description: description}.compact
         end
 
-        def object_schema(description: nil, reference: nil, &block)
-          if reference
-            reference(reference)
+        def object_schema(description: nil, of: nil, &block)
+          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 instance, convert it to reference
+            elsif schema_class?(result) && sub_schema.properties.empty?
+              schema_class_to_inline_schema(result).merge(description ? {description: description} : {})
             else
               {
                 type: "object",

lib/ruby_llm/schema/dsl/utilities.rb

@@ -36,8 +36,26 @@ 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, of
+          raise InvalidArrayTypeError, "Invalid array type: #{of.inspect}. Must be a primitive type (:string, :number, etc.), a symbol reference, or a Schema class."
+        end
+
+        def determine_object_reference(of, description = nil)
+          result = case of
+          when Symbol
+            reference(of)
+          when Class
+            if schema_class?(of)
+              schema_class_to_inline_schema(of)
+            else
+              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."
+          end
+
+          description ? result.merge(description: description) : result
         end
 
         def collect_schemas_from_block(&block)
@@ -55,13 +73,34 @@ def collect_schemas_from_block(&block)
             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 primitive_type?(type)
           type.is_a?(Symbol) && PRIMITIVE_TYPES.include?(type)
         end
+
+        def schema_class?(type)
+          type.is_a?(Class) && type < Schema
+        end
+
+        def schema_class_to_inline_schema(schema_class)
+          # 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
+          end
+        end
       end
     end
   end

lib/ruby_llm/schema/errors.rb

@@ -14,8 +14,15 @@ def initialize(type)
 
     # Raised when an invalid array type is specified
     class InvalidArrayTypeError < Error
-      def initialize(type)
-        super("Invalid array type: #{type}")
+      def initialize(message)
+        super
+      end
+    end
+
+    # Raised when an invalid object type is specified
+    class InvalidObjectTypeError < Error
+      def initialize(message)
+        super
       end
     end
 

lib/ruby_llm/schema/json_output.rb

@@ -6,17 +6,21 @@ 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,
+          strict: self.class.strict
+        }
+
+        # 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: {
-            :type => "object",
-            :properties => self.class.properties,
-            :required => self.class.required_properties,
-            :additionalProperties => self.class.additional_properties,
-            :strict => self.class.strict,
-            "$defs" => self.class.definitions
-          }
+          schema: schema_hash
         }
       end