lluminary 0.1.4 → 0.2.1

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,8 +20,15 @@ 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, :custom_validation_methods
+        end
+
+        self.schema_fields = fields
+        self.custom_validation_methods = custom_validations
+
         # Add accessors for each field
         fields.each_key do |name|
           define_method(name) { @attributes[name.to_s] }
@@ -29,11 +37,23 @@ module Lluminary
 
         # Add raw_response field and validation
         define_method(:raw_response) { @attributes["raw_response"] }
-        define_method(:raw_response=) do |value|
+        define_method("raw_response=") do |value|
           @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)
@@ -41,92 +61,44 @@ module Lluminary
               record.errors.add(:raw_response, "must be valid JSON")
             end
           end
-        end
-
-        # Add type validations
-        validate do |record|
-          def validate_array_field(
-            record,
-            name,
-            value,
-            element_type,
-            path = nil
-          )
-            field_name = path || name
-
-            unless value.is_a?(Array)
-              record.errors.add(field_name, "must be an Array")
-              return
-            end
-
-            return unless element_type # untyped array
-
-            value.each_with_index do |element, index|
-              current_path = "#{field_name}[#{index}]"
-
-              case element_type[:type]
-              when :array
-                validate_array_field(
-                  record,
-                  name,
-                  element,
-                  element_type[:element_type],
-                  current_path
-                )
-              when :string
-                unless element.is_a?(String)
-                  record.errors.add(current_path, "must be a String")
-                end
-              when :integer
-                unless element.is_a?(Integer)
-                  record.errors.add(current_path, "must be an Integer")
-                end
-              when :boolean
-                unless [true, false].include?(element)
-                  record.errors.add(current_path, "must be true or false")
-                end
-              when :float
-                unless element.is_a?(Float)
-                  record.errors.add(current_path, "must be a float")
-                end
-              when :datetime
-                unless element.is_a?(DateTime)
-                  record.errors.add(current_path, "must be a DateTime")
-                end
-              end
-            end
-          end
 
           record.attributes.each do |name, value|
             next if name == "raw_response"
             next if value.nil?
 
-            field = fields[name.to_sym]
+            field = self.class.schema_fields[name.to_sym]
             next unless field
 
             case field[:type]
+            when :hash
+              validate_hash_field(record, name.to_s.capitalize, value, field)
+            when :array
+              validate_array_field(
+                record,
+                name.to_s.capitalize,
+                value,
+                field[:element_type]
+              )
             when :string
               unless value.is_a?(String)
-                record.errors.add(name, "must be a String")
+                record.errors.add(name.to_s.capitalize, "must be a String")
               end
             when :integer
               unless value.is_a?(Integer)
-                record.errors.add(name, "must be an Integer")
+                record.errors.add(name.to_s.capitalize, "must be an Integer")
               end
             when :boolean
               unless [true, false].include?(value)
-                record.errors.add(name, "must be true or false")
+                record.errors.add(name.to_s.capitalize, "must be true or false")
               end
             when :float
               unless value.is_a?(Float)
-                record.errors.add(name, "must be a float")
+                record.errors.add(name.to_s.capitalize, "must be a float")
               end
             when :datetime
               unless value.is_a?(DateTime)
-                record.errors.add(name, "must be a DateTime")
+                record.errors.add(name.to_s.capitalize, "must be a DateTime")
               end
-            when :array
-              validate_array_field(record, name, value, field[:element_type])
             end
           end
         end
@@ -138,6 +110,118 @@ module Lluminary
         define_singleton_method(:model_name) do
           ActiveModel::Name.new(self, nil, "SchemaModel")
         end
+
+        private
+
+        def validate_hash_field(
+          record,
+          name,
+          value,
+          field_definition,
+          path = nil
+        )
+          field_name = path || name
+
+          unless value.is_a?(Hash)
+            record.errors.add(field_name, "must be a Hash")
+            return
+          end
+
+          field_definition[:fields].each do |key, field|
+            current_path = path ? "#{path}[#{key}]" : "#{field_name}[#{key}]"
+            # Try both string and symbol keys
+            field_value = value[key.to_s] || value[key.to_sym]
+
+            next if field_value.nil?
+
+            case field[:type]
+            when :hash
+              validate_hash_field(record, key, field_value, field, current_path)
+            when :array
+              validate_array_field(
+                record,
+                key,
+                field_value,
+                field[:element_type],
+                current_path
+              )
+            when :string
+              unless field_value.is_a?(String)
+                record.errors.add(current_path, "must be a String")
+              end
+            when :integer
+              unless field_value.is_a?(Integer)
+                record.errors.add(current_path, "must be an Integer")
+              end
+            when :boolean
+              unless [true, false].include?(field_value)
+                record.errors.add(current_path, "must be true or false")
+              end
+            when :float
+              unless field_value.is_a?(Float)
+                record.errors.add(current_path, "must be a float")
+              end
+            when :datetime
+              unless field_value.is_a?(DateTime)
+                record.errors.add(current_path, "must be a DateTime")
+              end
+            end
+          end
+        end
+
+        def validate_array_field(record, name, value, element_type, path = nil)
+          field_name = path || name
+
+          unless value.is_a?(Array)
+            record.errors.add(field_name, "must be an Array")
+            return
+          end
+
+          return unless element_type # untyped array
+
+          value.each_with_index do |element, index|
+            current_path = "#{field_name}[#{index}]"
+
+            case element_type[:type]
+            when :hash
+              validate_hash_field(
+                record,
+                name,
+                element,
+                element_type,
+                current_path
+              )
+            when :array
+              validate_array_field(
+                record,
+                name,
+                element,
+                element_type[:element_type],
+                current_path
+              )
+            when :string
+              unless element.is_a?(String)
+                record.errors.add(current_path, "must be a String")
+              end
+            when :integer
+              unless element.is_a?(Integer)
+                record.errors.add(current_path, "must be an Integer")
+              end
+            when :boolean
+              unless [true, false].include?(element)
+                record.errors.add(current_path, "must be true or false")
+              end
+            when :float
+              unless element.is_a?(Float)
+                record.errors.add(current_path, "must be a float")
+              end
+            when :datetime
+              unless element.is_a?(DateTime)
+                record.errors.add(current_path, "must be a DateTime")
+              end
+            end
+          end
+        end
       end
     end
   end

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/examples/character_profiler_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require "spec_helper"
+require_relative "../../examples/character_profiler"
+
+RSpec.describe CharacterProfiler do
+  let(:sample_text) { <<~TEXT }
+    Eliza Montenegro was not the kind of person who made a grand entrance, despite her striking appearance. 
+    At 5'9" with curly auburn hair that framed an angular face, she preferred tailored blazers and vintage boots that had seen better days.
+    
+    Her colleagues at the research lab respected her brilliant mind but found her difficult to read. She spoke rarely in meetings, 
+    but when she did, everyone listened. The only time she seemed to lower her guard was around Dr. Chen, her mentor of fifteen years,
+    or when discussing her passion project: developing affordable water filtration systems for remote villages like the one her grandmother grew up in.
+  TEXT
+
+  describe "input validation" do
+    it "accepts valid text input" do
+      expect { described_class.call!(text: sample_text) }.not_to raise_error
+    end
+
+    it "requires text to be present" do
+      expect do described_class.call!(text: "") end.to raise_error(
+        Lluminary::ValidationError
+      )
+    end
+  end
+
+  describe "output validation" do
+    let(:result) { described_class.call(text: sample_text) }
+
+    it "returns a character profile hash" do
+      character_profile = result.output.character_profile
+
+      expect(character_profile).to be_a(Hash)
+    end
+
+    it "includes basic profile fields" do
+      profile = result.output.character_profile
+
+      expect(profile["name"]).to be_a(String)
+      expect(profile["personality"]).to be_a(String)
+      expect(profile["complexity_score"]).to be_a(Float)
+    end
+
+    it "includes an appearance hash with required fields" do
+      appearance = result.output.character_profile["appearance"]
+
+      expect(appearance).to be_a(Hash)
+      expect(appearance["physical_traits"]).to be_a(String)
+      expect(appearance["style"]).to be_a(String)
+    end
+
+    it "includes an array of motivations" do
+      motivations = result.output.character_profile["motivations"]
+
+      expect(motivations).to be_an(Array)
+      expect(motivations).to all(be_a(String)) unless motivations.empty?
+    end
+
+    it "includes a relationships hash with allies and adversaries" do
+      relationships = result.output.character_profile["relationships"]
+
+      expect(relationships).to be_a(Hash)
+
+      expect(relationships["allies"]).to be_an(Array)
+      expect(relationships["allies"]).to all(be_a(String))
+
+      expect(relationships["adversaries"]).to be_an(Array)
+      expect(relationships["adversaries"]).to be_empty
+    end
+
+    it "has a complexity score between 0 and 1" do
+      score = result.output.character_profile["complexity_score"]
+      expect(score).to be >= 0.0
+      expect(score).to be <= 1.0
+    end
+  end
+
+  describe "prompt generation" do
+    let(:result) { described_class.call(text: sample_text) }
+
+    it "includes the text in the prompt" do
+      expect(result.prompt).to include(sample_text)
+    end
+  end
+end