lluminary 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20a5892da2184571fc6e1a681fc5ed81143c87a5abafc745249b0a28d5ef4f3a
-  data.tar.gz: 984b6467b9ac1a82af4107efbd72a4ae14ab05cae8e3838120dd0252ea0a5dc0
+  metadata.gz: cacc0edbbc80b69f4c95d6b9888707651dffc5189432920b1c814abed095ea01
+  data.tar.gz: 647f143f0be6053b7ca80868e2d6bd5058cfee8fae0d0e12a51ad59f8e8d5233
 SHA512:
-  metadata.gz: 85ad7a6f048fc3bad3ca587a638da18e5026dce9a7f5068e551170c5531f26a1b5da83b6fe193339dbeae1eaf087d50283d96742e5f0ace04905a9eb8abb73b1
-  data.tar.gz: 0c501c6277d1b58114998b005b02d0a6ab10aec14ed8f21026d8c682a20c9d09692ee818cb24252c2befd88f99aa578fa4302b880d6f8ed67b05ae8b56b94b87
+  metadata.gz: 63dce0789e7b175ad324d7de8f7bbd4c90da575e314f14cbd3c4ab9c6b3cab5b942cd279a15b545ac322f267bda221efd3988c6b7e9c7f2f930f1de0c1af87ac
+  data.tar.gz: 30a523b37b850f6603e466e05c49ceb8eeb03fb8ee81c3b237b97b175ace6082e0e97ace99b210e2807fb1d9feab2520a4b95753d5690e7fb46d02df1faa0389

data/lib/lluminary/models/base.rb

@@ -27,6 +27,8 @@ module Lluminary
           
           #{format_fields_descriptions(task.class.output_fields)}
           
+          #{format_additional_validations(task.class.output_custom_validations)}
+
           #{json_preamble}
           
           #{generate_example_json_object(task.class.output_fields)}
@@ -330,6 +332,15 @@ module Lluminary
           hash[subname] = generate_example_value(subname, subfield)
         end
       end
+
+      def format_additional_validations(custom_validations)
+        descriptions = custom_validations.map { |v| v[:description] }.compact
+        return "" if descriptions.empty?
+
+        section = ["Additional Validations:"]
+        descriptions.each { |desc| section << "- #{desc}" }
+        "#{section.join("\n")}\n"
+      end
     end
   end
 end

data/lib/lluminary/schema.rb

@@ -9,6 +9,7 @@ module Lluminary
     def initialize
       @fields = {}
       @validations = []
+      @custom_validations = []
     end
 
     def string(name, description: nil)
@@ -57,7 +58,7 @@ module Lluminary
       }
     end
 
-    attr_reader :fields
+    attr_reader :fields, :custom_validations
 
     def validates(*args, **options)
       @validations << [args, options]
@@ -72,18 +73,21 @@ module Lluminary
       end
     end
 
+    def validate(method_name, description: nil)
+      @custom_validations << { method: method_name, description: description }
+    end
+
     def validations_for(field_name)
       @validations.select { |args, _| args.include?(field_name) }
     end
 
     def schema_model
       @schema_model ||=
-        SchemaModel.build(fields: @fields, validations: @validations)
-    end
-
-    def validate(values)
-      instance = schema_model.new(values)
-      instance.valid? ? [] : instance.errors.full_messages
+        SchemaModel.build(
+          fields: @fields,
+          validations: @validations,
+          custom_validations: @custom_validations
+        )
     end
 
     # Internal class for defining array element types

data/lib/lluminary/schema_model.rb

@@ -8,6 +8,7 @@ module Lluminary
     include ActiveModel::Validations
 
     attr_reader :attributes
+    attr_accessor :task_instance
 
     def initialize(attributes = {})
       @attributes = attributes.transform_keys(&:to_s)
@@ -19,13 +20,14 @@ module Lluminary
       "#<#{self.class.name} #{attrs.inspect}>"
     end
 
-    def self.build(fields:, validations:)
+    def self.build(fields:, validations:, custom_validations: [])
       Class.new(self) do
         class << self
-          attr_accessor :schema_fields
+          attr_accessor :schema_fields, :custom_validation_methods
         end
 
         self.schema_fields = fields
+        self.custom_validation_methods = custom_validations
 
         # Add accessors for each field
         fields.each_key do |name|
@@ -39,7 +41,19 @@ module Lluminary
           @attributes["raw_response"] = value
         end
 
+        # Add custom validation hook
         validate do |record|
+          # Run custom validations from the task if present
+          if record.task_instance &&
+               !record.class.custom_validation_methods.empty?
+            record.class.custom_validation_methods.each do |validation|
+              method_name = validation[:method]
+              if record.task_instance.respond_to?(method_name)
+                record.task_instance.send(method_name)
+              end
+            end
+          end
+
           if record.raw_response
             begin
               JSON.parse(record.raw_response)

data/lib/lluminary/task.rb

@@ -74,12 +74,23 @@ module Lluminary
       def output_schema_model
         @output_schema&.schema_model || Schema.new.schema_model
       end
+
+      def output_custom_validations
+        @output_schema&.custom_validations || []
+      end
+
+      def input_custom_validations
+        @input_schema&.custom_validations || []
+      end
     end
 
     attr_reader :input, :output, :parsed_response
+    attr_accessor :validation_failed
 
     def initialize(input = {})
       @input = self.class.input_schema_model.new(input)
+      @input.task_instance = self
+      @validation_failed = false
       define_input_methods
     end
 
@@ -120,8 +131,30 @@ module Lluminary
       raise NotImplementedError, "Subclasses must implement task_prompt"
     end
 
+    # Helper for validation methods to add errors
+    def errors
+      # Points to the current model being validated - used by custom validation methods
+      if @current_model == :output && @output
+        @output.errors
+      else
+        @input.errors
+      end
+    end
+
     private
 
+    def define_output_accessor_methods
+      return unless @output
+
+      # Define accessor methods for each output field
+      @output.attributes.each_key do |name|
+        next if name == "raw_response"
+        singleton_class.class_eval do
+          define_method(name) { @output.attributes[name.to_s] }
+        end
+      end
+    end
+
     def validate_input
       validate_input!
     end
@@ -129,6 +162,7 @@ module Lluminary
     def process_response(response)
       @parsed_response = response[:parsed]
       @output = self.class.output_schema_model.new
+      @output.task_instance = self
       @output.raw_response = response[:raw]
 
       # Merge the parsed response first, then validate
@@ -160,6 +194,9 @@ module Lluminary
         @output.attributes.merge!(converted_response)
       end
 
+      # Define methods to access output attributes directly in validation methods
+      define_output_accessor_methods
+
       # Validate after merging
       @output.valid?
 

data/lib/lluminary/tasks/describe_openai_model.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Lluminary
+  module Tasks
+    class DescribeOpenAiModel < Lluminary::Task
+      use_provider :openai
+
+      input_schema do
+        string :model, description: "The OpenAI model to describe"
+      end
+
+      # {
+      #   "id": "gpt-4o-2024-11-20",
+      #   "family": "gpt-4o",
+      #   "variant": "standard",
+      #   "release_date": "2024-11-20",
+      #   "status": "GA",
+      #   "inputs": {"text": true, "image": true, "audio": false},
+      #   "outputs": {"text": true, "audio": false}
+      # }
+
+      output_schema do
+        hash :model_description, description: "The description of the model" do
+          string :id,
+                 description:
+                   "The full OpenAI API model ID being described. EG: 'gpt-4o-2024-11-20'"
+          string :family,
+                 description:
+                   "The OpenAI model family. EG: 'gpt-4o' or 'gpt-4.1-mini'"
+          string :variant, description: "The OpenAI model variant"
+          string :release_date,
+                 description: "The model's release date, if known."
+          string :status,
+                 description: "The OpenAI model status. EG: GA or preview"
+          hash :inputs, description: "The model's inputs" do
+            boolean :text, description: "Whether the model can process text"
+            boolean :image, description: "Whether the model can process images"
+            boolean :audio, description: "Whether the model can process audio"
+            string :other_inputs,
+                   description: "Other inputs the model can process"
+          end
+          hash :outputs, description: "The model's outputs" do
+            boolean :text, description: "Whether the model can output text"
+            boolean :image, description: "Whether the model can output images"
+            boolean :audio, description: "Whether the model can output audio"
+            string :other_outputs,
+                   description: "Other outputs the model can return"
+          end
+        end
+      end
+
+      def task_prompt
+        <<~PROMPT
+          You are an expert in OpenAI models. You will be given a model ID and asked to describe the model using structured data.
+
+          Model ID: #{input.model}
+        PROMPT
+      end
+    end
+  end
+end

data/lib/lluminary/tasks/identify_and_describe_open_ai_models.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Lluminary
+  module Tasks
+    class IdentifyAndDescribeOpenAiModels < Lluminary::Task
+      use_provider :bedrock, model: Lluminary::Models::Bedrock::AmazonNovaProV1
+
+      input_schema do
+        array :models, description: "List of OpenAI models" do
+          string
+        end
+      end
+
+      output_schema do
+        array :root_models,
+              description: "List of root models and their versions" do
+          hash do
+            string :name,
+                   description:
+                     "The root name of the model. For example, 'gpt-4' or 'gpt-4o'"
+            array :versions,
+                  description:
+                    "List of versions of the root model. For example, '0125-preview' or '0613' or '2024-04-09'" do
+              string
+            end
+          end
+        end
+      end
+
+      def task_prompt
+        <<~PROMPT
+          You are an expert in OpenAI models. You will be given a list of OpenAI models and asked to group them together by the "root" model type and capability and list the various versions of the root model.
+
+          Keep in mind that some "root" models have names with the same root name but different capabilities. For example, "gpt-4o" and "gpt-4o-audio" are distinct models, since they have different capabilities and each has their own versions.
+          
+          "gpt-4.5-preview" and "gpt-4.5-preview-2025-02-27" are examples of the "gpt-4.5" root model. There are two versions of the "gpt-4.5" root model: "preview" and "preview-2025-02-27".
+
+          Given the following list of models, please group them together by the "root" model type and list their versions. 
+
+          Your response will be used to generate code that will make use of the models and their verisons. 
+
+          It's critical that you represent every model and version from the following list in your response. Any model or version that is missed will be excluded from subsequent code generation and that will make them very, very sad. We don't want any sad models.
+
+          DO NOT include any other models or versions in your response other than those from ones listed below. Use your expertise in OpenAI models to distinguish between different "root" models and their versions.
+
+          Models: #{models.join(", ")}
+        PROMPT
+      end
+    end
+  end
+end

data/spec/lluminary/models/base_spec.rb

@@ -1035,6 +1035,38 @@ RSpec.describe Lluminary::Models::Base do
       end
     end
 
+    context "with custom validation descriptions" do
+      before do
+        task_class.output_schema do
+          string :name, description: "The person's name"
+          integer :confidence, description: "Confidence score from 0-100"
+          validate :validate_confidence_score,
+                   description: "Confidence score must be between 0 and 100"
+          validate :validate_other_thing, description: nil
+        end
+      end
+
+      it "includes an Additional Validations section with non-nil descriptions" do
+        prompt = model.format_prompt(task)
+        expect(prompt).to include("Additional Validations:")
+        expect(prompt).to include(
+          "- Confidence score must be between 0 and 100"
+        )
+        expect(prompt).not_to include("- \n") # Should not include a blank bullet for nil
+      end
+
+      it "omits Additional Validations section if all descriptions are nil" do
+        # Redefine schema with only nil descriptions
+        task_class.output_schema do
+          string :name, description: "The person's name"
+          validate :validate_confidence_score, description: nil
+          validate :validate_other_thing, description: nil
+        end
+        prompt = model.format_prompt(task)
+        expect(prompt).not_to include("Additional Validations:")
+      end
+    end
+
     context "JSON example generation" do
       context "with simple field types" do
         it "generates correct JSON example for string field" do

data/spec/lluminary/schema_model_spec.rb

@@ -169,4 +169,263 @@ RSpec.describe Lluminary::SchemaModel do
       )
     end
   end
+
+  describe "boolean field validation" do
+    let(:fields) do
+      { active: { type: :boolean, description: "Whether the item is active" } }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "accepts true values" do
+      instance = model_class.new(active: true)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "accepts false values" do
+      instance = model_class.new(active: false)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "accepts nil values" do
+      instance = model_class.new(active: nil)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "returns errors for non-boolean values" do
+      instance = model_class.new(active: "true")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Active must be true or false"
+      )
+
+      instance = model_class.new(active: 1)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Active must be true or false"
+      )
+    end
+
+    it "can be required using presence validation" do
+      validations = [[[:active], { presence: true }]]
+      model_class_with_presence =
+        described_class.build(fields: fields, validations: validations)
+      instance = model_class_with_presence.new(active: nil)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Active can't be blank"
+      )
+    end
+  end
+
+  describe "hash field with array validation" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: "Configuration",
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            tags: {
+              type: :array,
+              description: nil,
+              element_type: {
+                type: :string,
+                description: nil
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates arrays inside hashes" do
+      instance =
+        model_class.new(
+          config: {
+            name: "test",
+            tags: ["valid", 123, "also valid"]
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config[tags][1] must be a String"
+      )
+    end
+  end
+
+  describe "nested hash validation" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: nil,
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            database: {
+              type: :hash,
+              description: nil,
+              fields: {
+                host: {
+                  type: :string,
+                  description: nil
+                },
+                port: {
+                  type: :integer,
+                  description: nil
+                },
+                credentials: {
+                  type: :hash,
+                  description: nil,
+                  fields: {
+                    username: {
+                      type: :string,
+                      description: nil
+                    },
+                    password: {
+                      type: :string,
+                      description: nil
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates nested hashes" do
+      instance =
+        model_class.new(
+          config: {
+            name: "test",
+            database: {
+              host: 123, # should be string
+              port: "80", # should be integer
+              credentials: {
+                username: 456, # should be string
+                password: 789 # should be string
+              }
+            }
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config[database][host] must be a String",
+        "Config[database][port] must be an Integer",
+        "Config[database][credentials][username] must be a String",
+        "Config[database][credentials][password] must be a String"
+      )
+    end
+  end
+
+  describe "hash type enforcement" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: nil,
+          fields: {
+            host: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates that value is a hash" do
+      instance = model_class.new(config: "not a hash")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config must be a Hash"
+      )
+    end
+  end
+
+  describe "array of hashes validation" do
+    let(:fields) do
+      {
+        users: {
+          type: :array,
+          description: nil,
+          element_type: {
+            type: :hash,
+            description: nil,
+            fields: {
+              name: {
+                type: :string,
+                description: nil
+              },
+              age: {
+                type: :integer,
+                description: nil
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates hashes inside arrays" do
+      instance =
+        model_class.new(
+          users: [
+            { name: "Alice", age: 30 },
+            { name: 123, age: "invalid" }, # name should be string, age should be integer
+            { name: "Bob", age: 25 }
+          ]
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Users[1][name] must be a String",
+        "Users[1][age] must be an Integer"
+      )
+    end
+  end
+
+  describe "float field validation" do
+    let(:fields) { { score: { type: :float, description: "The score" } } }
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "accepts float values" do
+      instance = model_class.new(score: 3.14)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "accepts nil values" do
+      instance = model_class.new(score: nil)
+      expect(instance.valid?).to be true
+      expect(instance.errors.full_messages).to be_empty
+    end
+
+    it "returns errors for non-float values" do
+      instance = model_class.new(score: "not a float")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Score must be a float"
+      )
+
+      instance = model_class.new(score: 42)
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Score must be a float"
+      )
+    end
+  end
 end

data/spec/lluminary/schema_spec.rb

@@ -10,6 +10,58 @@ RSpec.describe Lluminary::Schema do
     end
   end
 
+  describe "#validate" do
+    it "registers a custom validation method" do
+      schema.validate(:validate_something)
+      expect(schema.custom_validations).to eq(
+        [{ method: :validate_something, description: nil }]
+      )
+    end
+
+    it "can register multiple validation methods" do
+      schema.validate(:validate_something)
+      schema.validate(:validate_something_else)
+      expect(schema.custom_validations).to eq(
+        [
+          { method: :validate_something, description: nil },
+          { method: :validate_something_else, description: nil }
+        ]
+      )
+    end
+
+    it "registers a custom validation method with a description" do
+      schema.validate(
+        :validate_score_range,
+        description: "Score must be between 0 and 100"
+      )
+      expect(schema.custom_validations).to eq(
+        [
+          {
+            method: :validate_score_range,
+            description: "Score must be between 0 and 100"
+          }
+        ]
+      )
+    end
+
+    it "registers multiple custom validations with and without descriptions" do
+      schema.validate(
+        :validate_score_range,
+        description: "Score must be between 0 and 100"
+      )
+      schema.validate(:validate_score_parity)
+      expect(schema.custom_validations).to eq(
+        [
+          {
+            method: :validate_score_range,
+            description: "Score must be between 0 and 100"
+          },
+          { method: :validate_score_parity, description: nil }
+        ]
+      )
+    end
+  end
+
   describe "#string" do
     it "adds a string field to the schema" do
       schema.string(:name)
@@ -213,12 +265,6 @@ RSpec.describe Lluminary::Schema do
       )
     end
 
-    it "validates array elements" do
-      schema.array(:numbers) { integer }
-      errors = schema.validate(numbers: [1, "2", 3])
-      expect(errors).to contain_exactly("Numbers[1] must be an Integer")
-    end
-
     it "supports hashes inside arrays" do
       schema.array(:users) do
         hash do
@@ -248,29 +294,6 @@ RSpec.describe Lluminary::Schema do
         }
       )
     end
-
-    it "validates hashes inside arrays" do
-      schema.array(:users) do
-        hash do
-          string :name
-          integer :age
-        end
-      end
-
-      errors =
-        schema.validate(
-          users: [
-            { name: "Alice", age: 30 },
-            { name: 123, age: "invalid" }, # name should be string, age should be integer
-            { name: "Bob", age: 25 }
-          ]
-        )
-
-      expect(errors).to contain_exactly(
-        "Users[1][name] must be a String",
-        "Users[1][age] must be an Integer"
-      )
-    end
   end
 
   describe "#hash" do
@@ -307,33 +330,6 @@ RSpec.describe Lluminary::Schema do
       )
     end
 
-    it "validates hash values" do
-      schema.hash(:config) do
-        string :host
-        integer :port
-      end
-
-      errors =
-        schema.validate(
-          config: {
-            host: 123, # should be string
-            port: "80" # should be integer
-          }
-        )
-
-      expect(errors).to contain_exactly(
-        "Config[host] must be a String",
-        "Config[port] must be an Integer"
-      )
-    end
-
-    it "validates that value is a hash" do
-      schema.hash(:config) { string :host }
-
-      errors = schema.validate(config: "not a hash")
-      expect(errors).to contain_exactly("Config must be a Hash")
-    end
-
     it "supports nested hashes" do
       schema.hash(:config) do
         string :name
@@ -389,42 +385,6 @@ RSpec.describe Lluminary::Schema do
       )
     end
 
-    it "validates nested hashes" do
-      schema.hash(:config) do
-        string :name
-        hash :database do
-          string :host
-          integer :port
-          hash :credentials do
-            string :username
-            string :password
-          end
-        end
-      end
-
-      errors =
-        schema.validate(
-          config: {
-            name: "test",
-            database: {
-              host: 123, # should be string
-              port: "80", # should be integer
-              credentials: {
-                username: 456, # should be string
-                password: 789 # should be string
-              }
-            }
-          }
-        )
-
-      expect(errors).to contain_exactly(
-        "Config[database][host] must be a String",
-        "Config[database][port] must be an Integer",
-        "Config[database][credentials][username] must be a String",
-        "Config[database][credentials][password] must be a String"
-      )
-    end
-
     it "supports arrays inside hashes" do
       schema.hash(:config) do
         string :name
@@ -454,25 +414,6 @@ RSpec.describe Lluminary::Schema do
         }
       )
     end
-
-    it "validates arrays inside hashes" do
-      schema.hash(:config) do
-        string :name
-        array :tags do
-          string
-        end
-      end
-
-      errors =
-        schema.validate(
-          config: {
-            name: "test",
-            tags: ["valid", 123, "also valid"] # second element should be string
-          }
-        )
-
-      expect(errors).to contain_exactly("Config[tags][1] must be a String")
-    end
   end
 
   describe "primitive types" do
@@ -509,136 +450,6 @@ RSpec.describe Lluminary::Schema do
       second_call = schema.fields
       expect(first_call).to be(second_call)
     end
-
-    context "with datetime fields" do
-      let(:schema) { described_class.new.tap { |s| s.datetime(:start_time) } }
-
-      it "accepts DateTime values" do
-        errors = schema.validate(start_time: DateTime.now)
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(start_time: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-DateTime values" do
-        errors = schema.validate(start_time: "2024-01-01")
-        expect(errors).to contain_exactly("Start time must be a DateTime")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :start_time, presence: true
-        errors = schema.validate(start_time: nil)
-        expect(errors).to contain_exactly("Start time can't be blank")
-      end
-    end
-  end
-
-  describe "#validate" do
-    let(:schema) do
-      described_class.new.tap do |s|
-        s.string(:name)
-        s.integer(:age)
-      end
-    end
-
-    it "returns no errors when all values match their field types" do
-      errors = schema.validate(name: "John", age: 30)
-      expect(errors).to be_empty
-    end
-
-    it "returns errors for type mismatches" do
-      errors = schema.validate(name: 123, age: "30")
-      expect(errors).to contain_exactly(
-        "Name must be a String",
-        "Age must be an Integer"
-      )
-    end
-
-    context "with boolean fields" do
-      let(:schema) { described_class.new.tap { |s| s.boolean(:active) } }
-
-      it "accepts true values" do
-        errors = schema.validate(active: true)
-        expect(errors).to be_empty
-      end
-
-      it "accepts false values" do
-        errors = schema.validate(active: false)
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(active: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-boolean values" do
-        errors = schema.validate(active: "true")
-        expect(errors).to contain_exactly("Active must be true or false")
-
-        errors = schema.validate(active: 1)
-        expect(errors).to contain_exactly("Active must be true or false")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :active, presence: true
-        errors = schema.validate(active: nil)
-        expect(errors).to contain_exactly("Active can't be blank")
-      end
-    end
-
-    context "with string fields" do
-      let(:schema) { described_class.new.tap { |s| s.string(:name) } }
-
-      it "accepts string values" do
-        errors = schema.validate(name: "John")
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(name: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-string values" do
-        errors = schema.validate(name: 123)
-        expect(errors).to contain_exactly("Name must be a String")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :name, presence: true
-        errors = schema.validate(name: nil)
-        expect(errors).to contain_exactly("Name can't be blank")
-      end
-    end
-
-    context "with integer fields" do
-      let(:schema) { described_class.new.tap { |s| s.integer(:age) } }
-
-      it "accepts integer values" do
-        errors = schema.validate(age: 30)
-        expect(errors).to be_empty
-      end
-
-      it "accepts nil values" do
-        errors = schema.validate(age: nil)
-        expect(errors).to be_empty
-      end
-
-      it "returns errors for non-integer values" do
-        errors = schema.validate(age: "30")
-        expect(errors).to contain_exactly("Age must be an Integer")
-      end
-
-      it "can be required using presence validation" do
-        schema.validates :age, presence: true
-        errors = schema.validate(age: nil)
-        expect(errors).to contain_exactly("Age can't be blank")
-      end
-    end
   end
 
   describe "ActiveModel validations" do
@@ -688,4 +499,32 @@ RSpec.describe Lluminary::Schema do
       expect(instance.valid?).to be true
     end
   end
+
+  describe "custom method validations" do
+    it "passes custom validations to schema model" do
+      schema = described_class.new
+      schema.integer(:score)
+      schema.validate(:validate_score_range)
+
+      model_class = schema.schema_model
+      method_names =
+        model_class.custom_validation_methods.map { |v| v[:method] }
+      expect(method_names).to contain_exactly(:validate_score_range)
+    end
+
+    it "accepts multiple custom validations" do
+      schema = described_class.new
+      schema.integer(:score)
+      schema.validate(:validate_score_range)
+      schema.validate(:validate_score_parity)
+
+      model_class = schema.schema_model
+      method_names =
+        model_class.custom_validation_methods.map { |v| v[:method] }
+      expect(method_names).to contain_exactly(
+        :validate_score_range,
+        :validate_score_parity
+      )
+    end
+  end
 end

data/spec/lluminary/task_custom_validation_spec.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+RSpec.describe "Task custom validations" do
+  # Test task classes
+  class TaskWithInputValidation < Lluminary::Task
+    use_provider :test
+
+    input_schema do
+      string :text
+      integer :min_length, description: "Minimum word length to count"
+
+      validate :validate_input_min_length
+    end
+
+    output_schema { integer :word_count }
+
+    def validate_input_min_length
+      min_length_value = @input.attributes["min_length"]
+      if min_length_value && min_length_value <= 0
+        @input.errors.add(:min_length, "must be positive")
+      end
+    end
+
+    def task_prompt
+      "Count words in: #{text}"
+    end
+  end
+
+  class TaskWithOutputValidation < Lluminary::Task
+    use_provider :test
+
+    input_schema { string :text }
+
+    output_schema do
+      string :sentiment,
+             description: "Sentiment of the text (positive, negative, neutral)"
+      integer :confidence, description: "Confidence score from 0-100"
+
+      validate :validate_confidence_range
+    end
+
+    def validate_confidence_range
+      confidence_value = @output.attributes["confidence"]
+      if confidence_value && (confidence_value < 0 || confidence_value > 100)
+        @output.errors.add(:confidence, "must be between 0 and 100")
+      end
+    end
+
+    def task_prompt
+      "Analyze sentiment of: #{text}"
+    end
+  end
+
+  class TaskWithBothValidations < Lluminary::Task
+    use_provider :test
+
+    input_schema do
+      string :text
+      array :hashtags, description: "Hashtags to analyze" do
+        string
+      end
+
+      validate :validate_hashtags
+    end
+
+    output_schema do
+      array :relevant_hashtags do
+        string
+      end
+      hash :analysis do
+        string :top_hashtag
+        integer :count
+      end
+
+      validate :validate_top_hashtag
+    end
+
+    def validate_hashtags
+      hashtags_value = @input.attributes["hashtags"]
+      if hashtags_value && hashtags_value.any? &&
+           !hashtags_value.all? { |h| h.start_with?("#") }
+        @input.errors.add(:hashtags, "must all start with # symbol")
+      end
+    end
+
+    def validate_top_hashtag
+      top_hashtag = @output.attributes.dig("analysis", "top_hashtag")
+      relevant_hashtags = @output.attributes["relevant_hashtags"]
+      if top_hashtag && relevant_hashtags &&
+           !relevant_hashtags.include?(top_hashtag)
+        @output.errors.add(
+          :analysis,
+          "top hashtag must be in the relevant_hashtags list"
+        )
+      end
+    end
+
+    def task_prompt
+      "Analyze hashtags in: #{text}"
+    end
+  end
+
+  # Override Test provider for predictable responses
+  class TestProvider < Lluminary::Providers::Test
+    def initialize(response_data = nil)
+      @response_data = response_data || {}
+    end
+
+    def call(prompt, task)
+      if @response_data[task.class.name]
+        @response_data[task.class.name]
+      else
+        { raw: "{}", parsed: {} }
+      end
+    end
+  end
+
+  describe "input validations" do
+    before do
+      # Reset the provider to use our test provider
+      TaskWithInputValidation.provider = TestProvider.new
+    end
+
+    it "validates input with custom methods" do
+      task = TaskWithInputValidation.new(text: "Hello world", min_length: 0)
+      expect(task.valid?).to be false
+      expect(task.input.errors.full_messages).to include(
+        "Min length must be positive"
+      )
+    end
+
+    it "accepts valid input" do
+      task = TaskWithInputValidation.new(text: "Hello world", min_length: 3)
+      expect(task.valid?).to be true
+      expect(task.input.errors.full_messages).to be_empty
+    end
+
+    it "rejects invalid input in call" do
+      result = TaskWithInputValidation.call(text: "Hello world", min_length: -5)
+      expect(result.input.valid?).to be false
+      expect(result.output).to be_nil
+    end
+  end
+
+  describe "output validations" do
+    before do
+      # Setup test provider with custom responses
+      responses = {
+        "TaskWithOutputValidation" => {
+          raw: '{"sentiment": "positive", "confidence": 150}',
+          parsed: {
+            "sentiment" => "positive",
+            "confidence" => 150 # Invalid: over 100
+          }
+        }
+      }
+      TaskWithOutputValidation.provider = TestProvider.new(responses)
+    end
+
+    it "validates output with custom methods" do
+      result = TaskWithOutputValidation.call(text: "I love this product!")
+      expect(result.output.valid?).to be false
+      expect(result.output.errors.full_messages).to include(
+        "Confidence must be between 0 and 100"
+      )
+    end
+
+    it "works with valid output" do
+      # Patch the provider with valid data for this test
+      valid_responses = {
+        "TaskWithOutputValidation" => {
+          raw: '{"sentiment": "positive", "confidence": 95}',
+          parsed: {
+            "sentiment" => "positive",
+            "confidence" => 95 # Valid: between 0-100
+          }
+        }
+      }
+      TaskWithOutputValidation.provider = TestProvider.new(valid_responses)
+
+      result = TaskWithOutputValidation.call(text: "I love this product!")
+      expect(result.output.valid?).to be true
+      expect(result.output.errors.full_messages).to be_empty
+      expect(result.output.sentiment).to eq("positive")
+      expect(result.output.confidence).to eq(95)
+    end
+  end
+
+  describe "both input and output validations" do
+    before do
+      # Setup test provider with custom responses
+      responses = {
+        "TaskWithBothValidations" => {
+          raw:
+            '{"relevant_hashtags": ["#ruby", "#rails"], "analysis": {"top_hashtag": "#javascript", "count": 5}}',
+          parsed: {
+            "relevant_hashtags" => %w[#ruby #rails],
+            "analysis" => {
+              "top_hashtag" => "#javascript", # Invalid: not in relevant_hashtags
+              "count" => 5
+            }
+          }
+        }
+      }
+      TaskWithBothValidations.provider = TestProvider.new(responses)
+    end
+
+    it "validates input with custom methods" do
+      task =
+        TaskWithBothValidations.new(
+          text: "Hello world",
+          hashtags: %w[ruby rails]
+        )
+      expect(task.valid?).to be false
+      expect(task.input.errors.full_messages).to include(
+        "Hashtags must all start with # symbol"
+      )
+    end
+
+    it "validates output with custom methods" do
+      # Input is valid for this test
+      result =
+        TaskWithBothValidations.call(
+          text: "Hello world",
+          hashtags: %w[#ruby #rails]
+        )
+      expect(result.output.valid?).to be false
+      expect(result.output.errors.full_messages).to include(
+        "Analysis top hashtag must be in the relevant_hashtags list"
+      )
+    end
+
+    it "works with valid input and output" do
+      # Patch the provider with valid data for this test
+      valid_responses = {
+        "TaskWithBothValidations" => {
+          raw:
+            '{"relevant_hashtags": ["#ruby", "#rails"], "analysis": {"top_hashtag": "#ruby", "count": 5}}',
+          parsed: {
+            "relevant_hashtags" => %w[#ruby #rails],
+            "analysis" => {
+              "top_hashtag" => "#ruby", # Valid: in relevant_hashtags
+              "count" => 5
+            }
+          }
+        }
+      }
+      TaskWithBothValidations.provider = TestProvider.new(valid_responses)
+
+      result =
+        TaskWithBothValidations.call(
+          text: "Hello world",
+          hashtags: %w[#ruby #rails]
+        )
+      expect(result.input.valid?).to be true
+      expect(result.output.valid?).to be true
+      expect(result.output.relevant_hashtags).to eq(%w[#ruby #rails])
+      expect(result.output.analysis["top_hashtag"]).to eq("#ruby")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+require "simplecov"
+SimpleCov.start { add_filter "/spec/" } if ENV["COVERAGE"]
+
 require "dotenv"
 Dotenv.load
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lluminary
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Doug Hughes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-24 00:00:00.000000000 Z
+date: 2025-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -170,6 +170,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
 description: 'Lluminary is a framework for building applications that leverage Large
   Language Models. It provides a structured way to define tasks, manage prompts, and
   handle LLM interactions.
@@ -197,6 +211,8 @@ files:
 - lib/lluminary/schema.rb
 - lib/lluminary/schema_model.rb
 - lib/lluminary/task.rb
+- lib/lluminary/tasks/describe_openai_model.rb
+- lib/lluminary/tasks/identify_and_describe_open_ai_models.rb
 - lib/lluminary/validation_error.rb
 - lib/lluminary/version.rb
 - spec/examples/analyze_text_spec.rb
@@ -220,6 +236,7 @@ files:
 - spec/lluminary/result_spec.rb
 - spec/lluminary/schema_model_spec.rb
 - spec/lluminary/schema_spec.rb
+- spec/lluminary/task_custom_validation_spec.rb
 - spec/lluminary/task_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/dhughes/lluminary