lluminary 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 187dc38fab8e09fd65ffb2db359e914f16dc79ace8ff9d058de01f547db0921c
-  data.tar.gz: 6a9a08f01d36966529c3c97e1877834df7a59e41347f68ffcba4c37a56597a4e
+  metadata.gz: 43ca21be47208b82183b4156be99d1e9816ea1013b2ee0c5258df158b0f4f2c1
+  data.tar.gz: 4f835024abc67bcd6bb9dd108fd49431eec6a152f168e31592b2d5317b982889
 SHA512:
-  metadata.gz: 202c4b2f46a3a0f35e978406055781fe3c85d390ca5e520955b8fad80734dbe6434a9034767f149141876a28a69e50e2636c0064d1119ede7e2314df7e49bac1
-  data.tar.gz: f0c17df74edfc0db4b7eb97917355f6c32da8761fa294ddd030f86bdc0540f208ae5220700b2d1a752ad25a1665367f7bfc6f02e51df3fe76b4ed79a51bef46a
+  metadata.gz: 2cc7b7322ec931bf1d0c5783b3dfbd26bb3c7fff841d834cc120d271c6ecef3e22472ba278c5cee8932685cfe71c850950a0e6305b88c0d997df7b3ebc0fdca4
+  data.tar.gz: b9f95c68e583a7819bb4b37e36c0b40d6856ce9f4261aea7efe78018823e950471a306f223033747e32d25fb81790a64af1f9cec70ee102be4a2811ccfcdede4

data/lib/lluminary/models/base.rb

@@ -175,6 +175,18 @@ module Lluminary
           end
         when :hash
           "object"
+        when :dictionary
+          if field[:value_type].nil?
+            "object"
+          elsif field[:value_type][:type] == :array
+            "object with array values"
+          elsif field[:value_type][:type] == :datetime
+            "object with datetime values in ISO8601 format"
+          elsif field[:value_type][:type] == :hash
+            "object with object values"
+          else
+            "object with #{field[:value_type][:type]} values"
+          end
         else
           field[:type].to_s
         end
@@ -294,6 +306,8 @@ module Lluminary
           generate_array_example(name, field)
         when :hash
           generate_hash_example(name, field)
+        when :dictionary
+          generate_dictionary_example(name, field)
         end
       end
 
@@ -333,6 +347,37 @@ module Lluminary
         end
       end
 
+      def generate_dictionary_example(name, field)
+        return {} unless field[:value_type]
+
+        case field[:value_type][:type]
+        when :string
+          { "some_key" => "first value", "other_key" => "second value" }
+        when :integer
+          { "some_key" => 1, "other_key" => 2 }
+        when :float
+          { "some_key" => 1.0, "other_key" => 2.0 }
+        when :boolean
+          { "some_key" => true, "other_key" => false }
+        when :datetime
+          {
+            "some_key" => "2024-01-01T12:00:00+00:00",
+            "other_key" => "2024-01-02T12:00:00+00:00"
+          }
+        when :array
+          if field[:value_type][:element_type]
+            inner_example = generate_array_example("item", field[:value_type])
+            { "some_key" => inner_example, "other_key" => inner_example }
+          else
+            { "some_key" => [], "other_key" => [] }
+          end
+        when :hash
+          example =
+            generate_hash_example(name.to_s.singularize, field[:value_type])
+          { "some_key" => example, "other_key" => example }
+        end
+      end
+
       def format_additional_validations(custom_validations)
         descriptions = custom_validations.map { |v| v[:description] }.compact
         return "" if descriptions.empty?

data/lib/lluminary/schema.rb

@@ -36,7 +36,7 @@ module Lluminary
       field = { type: :array, description: description }
 
       if block
-        element_schema = ArrayElementSchema.new
+        element_schema = ElementTypeSchema.new
         field[:element_type] = element_schema.instance_eval(&block)
       end
 
@@ -58,6 +58,21 @@ module Lluminary
       }
     end
 
+    def dictionary(name, description: nil, &block)
+      unless block
+        raise ArgumentError, "Dictionary fields must be defined with a block"
+      end
+
+      element_schema = ElementTypeSchema.new
+      value_type = element_schema.instance_eval(&block)
+
+      @fields[name] = {
+        type: :dictionary,
+        description: description,
+        value_type: value_type
+      }
+    end
+
     attr_reader :fields, :custom_validations
 
     def validates(*args, **options)
@@ -90,8 +105,8 @@ module Lluminary
         )
     end
 
-    # Internal class for defining array element types
-    class ArrayElementSchema
+    # Internal class for defining element types for arrays and dictionaries (or any other container-type objects)
+    class ElementTypeSchema
       def string(description: nil)
         { type: :string, description: description }
       end
@@ -114,7 +129,7 @@ module Lluminary
 
       def array(description: nil, &block)
         field = { type: :array, description: description }
-        field[:element_type] = ArrayElementSchema.new.instance_eval(
+        field[:element_type] = ElementTypeSchema.new.instance_eval(
           &block
         ) if block
         field
@@ -130,6 +145,17 @@ module Lluminary
 
         { type: :hash, description: description, fields: nested_schema.fields }
       end
+
+      def dictionary(description: nil, &block)
+        unless block
+          raise ArgumentError, "Dictionary fields must be defined with a block"
+        end
+
+        element_schema = ElementTypeSchema.new
+        value_type = element_schema.instance_eval(&block)
+
+        { type: :dictionary, description: description, value_type: value_type }
+      end
     end
   end
 end

data/lib/lluminary/schema_model.rb

@@ -71,14 +71,11 @@ module Lluminary
 
             case field[:type]
             when :hash
-              validate_hash_field(record, name.to_s.capitalize, value, field)
+              validate_hash_field(record, name, value, field)
             when :array
-              validate_array_field(
-                record,
-                name.to_s.capitalize,
-                value,
-                field[:element_type]
-              )
+              validate_array_field(record, name, value, field[:element_type])
+            when :dictionary
+              validate_dictionary_field(record, name, value, field[:value_type])
             when :string
               unless value.is_a?(String)
                 record.errors.add(name.to_s.capitalize, "must be a String")
@@ -113,6 +110,72 @@ module Lluminary
 
         private
 
+        def validate_dictionary_field(
+          record,
+          name,
+          value,
+          value_type,
+          path = nil
+        )
+          field_name = path || name
+
+          unless value.is_a?(Hash)
+            record.errors.add(field_name, "must be a Hash")
+            return
+          end
+
+          value.each do |key, val|
+            current_path = "#{field_name}[#{key}]"
+
+            case value_type[:type]
+            when :string
+              unless val.is_a?(String)
+                record.errors.add(current_path, "must be a String")
+              end
+            when :integer
+              unless val.is_a?(Integer)
+                record.errors.add(current_path, "must be an Integer")
+              end
+            when :boolean
+              unless [true, false].include?(val)
+                record.errors.add(current_path, "must be true or false")
+              end
+            when :float
+              unless val.is_a?(Float)
+                record.errors.add(current_path, "must be a float")
+              end
+            when :datetime
+              unless val.is_a?(DateTime)
+                record.errors.add(current_path, "must be a DateTime")
+              end
+            when :hash
+              validate_hash_field(
+                record,
+                current_path,
+                val,
+                value_type,
+                current_path
+              )
+            when :array
+              validate_array_field(
+                record,
+                current_path,
+                val,
+                value_type[:element_type],
+                current_path
+              )
+            when :dictionary
+              validate_dictionary_field(
+                record,
+                current_path,
+                val,
+                value_type[:value_type],
+                current_path
+              )
+            end
+          end
+        end
+
         def validate_hash_field(
           record,
           name,
@@ -145,6 +208,14 @@ module Lluminary
                 field[:element_type],
                 current_path
               )
+            when :dictionary
+              validate_dictionary_field(
+                record,
+                key,
+                field_value,
+                field[:value_type],
+                current_path
+              )
             when :string
               unless field_value.is_a?(String)
                 record.errors.add(current_path, "must be a String")
@@ -199,6 +270,14 @@ module Lluminary
                 element_type[:element_type],
                 current_path
               )
+            when :dictionary
+              validate_dictionary_field(
+                record,
+                name,
+                element,
+                element_type[:value_type],
+                current_path
+              )
             when :string
               unless element.is_a?(String)
                 record.errors.add(current_path, "must be a String")

data/spec/examples/text_emotion_analyzer_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "spec_helper"
+require_relative "../../examples/text_emotion_analyzer"
+
+RSpec.describe TextEmotionAnalyzer do
+  let(:sample_text) { <<~TEXT }
+      The sun was setting behind the mountains, casting long shadows across the valley. 
+      Sarah felt a mix of emotions as she watched the last rays of light disappear. 
+      There was a deep sense of peace, but also a tinge of sadness knowing this beautiful moment would soon be gone. 
+      She smiled through her tears, grateful for the experience yet longing for it to last just a little longer.
+    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 { described_class.call!(text: "") }.to raise_error(
+        Lluminary::ValidationError
+      )
+    end
+  end
+
+  describe "output validation" do
+    let(:result) { described_class.call(text: sample_text) }
+
+    it "returns a dictionary of emotion scores" do
+      expect(result.output.emotion_scores).to be_a(Hash)
+      expect(result.output.emotion_scores).not_to be_empty
+    end
+
+    it "returns float scores between 0.0 and 1.0" do
+      result.output.emotion_scores.each do |emotion, score|
+        expect(score).to be_a(Float)
+        expect(score).to be_between(0.0, 1.0)
+      end
+    end
+
+    it "returns a dominant emotion" do
+      expect(result.output.dominant_emotion).to be_a(String)
+      expect(result.output.dominant_emotion).not_to be_empty
+    end
+
+    it "returns an analysis" do
+      expect(result.output.analysis).to be_a(String)
+      expect(result.output.analysis).not_to be_empty
+    end
+
+    it "returns valid JSON response" do
+      expect(result.output.raw_response).to be_a(String)
+      expect { JSON.parse(result.output.raw_response) }.not_to raise_error
+      json = JSON.parse(result.output.raw_response)
+      expect(json).to have_key("emotion_scores")
+      expect(json).to have_key("dominant_emotion")
+      expect(json).to have_key("analysis")
+    end
+  end
+
+  describe "emotion detection" do
+    it "detects multiple emotions in complex text" do
+      result = described_class.call(text: sample_text)
+      expect(result.output.emotion_scores.size).to be >= 2
+    end
+
+    it "identifies the highest scoring emotion as dominant" do
+      result = described_class.call(text: sample_text)
+      dominant_score =
+        result.output.emotion_scores[result.output.dominant_emotion]
+      result.output.emotion_scores.each do |emotion, score|
+        expect(score).to be <= dominant_score
+      end
+    end
+  end
+end

data/spec/lluminary/models/base_spec.rb

@@ -1409,6 +1409,147 @@ RSpec.describe Lluminary::Models::Base do
           expect(prompt).to include(expected_json)
         end
       end
+
+      context "with dictionary fields" do
+        it "formats dictionary field description correctly" do
+          task_class.output_schema do
+            dictionary :emotion_scores,
+                       description: "Scores for each detected emotion" do
+              float
+            end
+          end
+
+          prompt = model.format_prompt(task)
+
+          expected_description = <<~DESCRIPTION.chomp
+            # emotion_scores
+            Description: Scores for each detected emotion
+            Type: object with float values
+            Example: {"some_key":1.0,"other_key":2.0}
+          DESCRIPTION
+
+          expect(prompt).to include(expected_description)
+        end
+
+        it "formats dictionary of arrays field description correctly" do
+          task_class.output_schema do
+            dictionary :categories, description: "Categories and their items" do
+              array { string }
+            end
+          end
+
+          prompt = model.format_prompt(task)
+
+          expected_description = <<~DESCRIPTION.chomp
+            # categories
+            Description: Categories and their items
+            Type: object with array values
+            Example: {"some_key":["first item","second item"],"other_key":["first item","second item"]}
+          DESCRIPTION
+
+          expect(prompt).to include(expected_description)
+        end
+
+        it "formats dictionary of objects field description correctly" do
+          task_class.output_schema do
+            dictionary :users, description: "User profiles" do
+              hash do
+                string :name
+                integer :age
+              end
+            end
+          end
+
+          prompt = model.format_prompt(task)
+
+          expected_description = <<~DESCRIPTION.chomp
+            # users
+            Description: User profiles
+            Type: object with object values
+            Example: {"some_key":{"name":"your name here","age":0},"other_key":{"name":"your name here","age":0}}
+          DESCRIPTION
+
+          expect(prompt).to include(expected_description)
+        end
+
+        it "generates correct JSON example for dictionary of floats" do
+          task_class.output_schema do
+            dictionary :scores, description: "Scores for each item" do
+              float
+            end
+          end
+
+          prompt = model.format_prompt(task)
+
+          expected_json = <<~JSON.chomp
+            {
+              "scores": {
+                "some_key": 1.0,
+                "other_key": 2.0
+              }
+            }
+          JSON
+
+          expect(prompt).to include(expected_json)
+        end
+
+        it "generates correct JSON example for dictionary of arrays" do
+          task_class.output_schema do
+            dictionary :categories, description: "Categories and their items" do
+              array { string }
+            end
+          end
+
+          prompt = model.format_prompt(task)
+
+          expected_json = <<~JSON.chomp
+            {
+              "categories": {
+                "some_key": [
+                  "first item",
+                  "second item"
+                ],
+                "other_key": [
+                  "first item",
+                  "second item"
+                ]
+              }
+            }
+          JSON
+
+          expect(prompt).to include(expected_json)
+        end
+
+        it "generates correct JSON example for dictionary of objects" do
+          task_class.output_schema do
+            dictionary :users, description: "User profiles" do
+              hash do
+                string :name
+                integer :age
+              end
+            end
+          end
+
+          prompt = model.format_prompt(task)
+
+          expected_json = <<~JSON.chomp
+            {
+              "users": {
+                "some_key": {
+                  "name": "your name here",
+                  "age": 0
+                },
+                "other_key": {
+                  "name": "your name here",
+                  "age": 0
+                }
+              }
+            }
+          JSON
+
+          expect(prompt).to include(expected_json)
+        end
+      end
     end
   end
 end

data/spec/lluminary/schema_model_spec.rb

@@ -428,4 +428,238 @@ RSpec.describe Lluminary::SchemaModel do
       )
     end
   end
+
+  describe "dictionary type enforcement" do
+    let(:fields) do
+      {
+        tags: {
+          type: :dictionary,
+          description: nil,
+          value_type: {
+            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(tags: "not a hash")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Tags must be a Hash"
+      )
+    end
+
+    it "validates dictionary value types" do
+      instance = model_class.new(tags: { "tag1" => "valid", "tag2" => 123 })
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Tags[tag2] must be a String"
+      )
+    end
+
+    it "accepts valid dictionary values" do
+      instance =
+        model_class.new(tags: { "tag1" => "valid", "tag2" => "also valid" })
+      expect(instance.valid?).to be true
+    end
+  end
+
+  describe "nested dictionary validation" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: nil,
+          fields: {
+            settings: {
+              type: :dictionary,
+              description: nil,
+              value_type: {
+                type: :integer,
+                description: nil
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates dictionaries inside hashes" do
+      instance =
+        model_class.new(
+          config: {
+            settings: {
+              "timeout" => 30,
+              "retries" => "3" # should be integer
+            }
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config[settings][retries] must be an Integer"
+      )
+    end
+  end
+
+  describe "dictionary of hashes validation" do
+    let(:fields) do
+      {
+        users: {
+          type: :dictionary,
+          description: nil,
+          value_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 dictionaries" do
+      instance =
+        model_class.new(
+          users: {
+            "user1" => {
+              name: "Alice",
+              age: 30
+            },
+            "user2" => {
+              name: 123,
+              age: "invalid"
+            } # name should be string, age should be integer
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Users[user2][name] must be a String",
+        "Users[user2][age] must be an Integer"
+      )
+    end
+  end
+
+  describe "dictionary of arrays validation" do
+    let(:fields) do
+      {
+        categories: {
+          type: :dictionary,
+          description: nil,
+          value_type: {
+            type: :array,
+            description: nil,
+            element_type: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates arrays inside dictionaries" do
+      instance =
+        model_class.new(
+          categories: {
+            "fruits" => %w[apple banana],
+            "numbers" => ["one", 2, "three"] # should all be strings
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Categories[numbers][1] must be a String"
+      )
+    end
+  end
+
+  describe "array of dictionaries validation" do
+    let(:fields) do
+      {
+        configs: {
+          type: :array,
+          description: nil,
+          element_type: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates dictionaries inside arrays" do
+      instance =
+        model_class.new(
+          configs: [
+            { "key1" => "value1", "key2" => "value2" },
+            { "key3" => "value3", "key4" => 123 } # should be string
+          ]
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Configs[1][key4] must be a String"
+      )
+    end
+  end
+
+  describe "hash with dictionary validation" do
+    let(:fields) do
+      {
+        config: {
+          type: :hash,
+          description: "Configuration",
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            settings: {
+              type: :dictionary,
+              description: nil,
+              value_type: {
+                type: :boolean,
+                description: nil
+              }
+            }
+          }
+        }
+      }
+    end
+    let(:model_class) { described_class.build(fields: fields, validations: []) }
+
+    it "validates dictionaries inside hashes" do
+      instance =
+        model_class.new(
+          config: {
+            name: "test",
+            settings: {
+              "enabled" => true,
+              "active" => "true" # should be boolean
+            }
+          }
+        )
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to contain_exactly(
+        "Config[settings][active] must be true or false"
+      )
+    end
+  end
 end

data/spec/lluminary/schema_spec.rb

@@ -294,6 +294,25 @@ RSpec.describe Lluminary::Schema do
         }
       )
     end
+
+    it "supports dictionaries inside arrays" do
+      schema.array(:configs) { dictionary { string } }
+
+      expect(schema.fields[:configs]).to eq(
+        {
+          type: :array,
+          description: nil,
+          element_type: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      )
+    end
   end
 
   describe "#hash" do
@@ -414,6 +433,210 @@ RSpec.describe Lluminary::Schema do
         }
       )
     end
+
+    it "supports dictionaries inside hashes" do
+      schema.hash(:config) do
+        string :name
+        dictionary :settings do
+          string
+        end
+      end
+
+      expect(schema.fields[:config]).to eq(
+        {
+          type: :hash,
+          description: nil,
+          fields: {
+            name: {
+              type: :string,
+              description: nil
+            },
+            settings: {
+              type: :dictionary,
+              description: nil,
+              value_type: {
+                type: :string,
+                description: nil
+              }
+            }
+          }
+        }
+      )
+    end
+  end
+
+  describe "#dictionary" do
+    it "adds a dictionary field to the schema" do
+      schema.dictionary(:tags) { string }
+      expect(schema.fields).to eq(
+        {
+          tags: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      )
+    end
+
+    it "adds a dictionary field with description" do
+      schema.dictionary(:tags, description: "A map of tags") { string }
+      expect(schema.fields).to eq(
+        {
+          tags: {
+            type: :dictionary,
+            description: "A map of tags",
+            value_type: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      )
+    end
+
+    it "requires a name for the dictionary field" do
+      expect { schema.dictionary }.to raise_error(ArgumentError)
+    end
+
+    it "requires a block for dictionary fields" do
+      expect { schema.dictionary(:tags) }.to raise_error(
+        ArgumentError,
+        "Dictionary fields must be defined with a block"
+      )
+    end
+
+    it "accepts string type without a name" do
+      schema.dictionary(:tags) { string }
+      expect(schema.fields).to eq(
+        {
+          tags: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      )
+    end
+
+    it "accepts integer type without a name" do
+      schema.dictionary(:scores) { integer }
+      expect(schema.fields).to eq(
+        {
+          scores: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :integer,
+              description: nil
+            }
+          }
+        }
+      )
+    end
+
+    it "accepts boolean type without a name" do
+      schema.dictionary(:flags) { boolean }
+      expect(schema.fields).to eq(
+        {
+          flags: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :boolean,
+              description: nil
+            }
+          }
+        }
+      )
+    end
+
+    it "accepts float type without a name" do
+      schema.dictionary(:ratings) { float }
+      expect(schema.fields).to eq(
+        {
+          ratings: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :float,
+              description: nil
+            }
+          }
+        }
+      )
+    end
+
+    it "accepts datetime type without a name" do
+      schema.dictionary(:timestamps) { datetime }
+      expect(schema.fields).to eq(
+        {
+          timestamps: {
+            type: :dictionary,
+            description: nil,
+            value_type: {
+              type: :datetime,
+              description: nil
+            }
+          }
+        }
+      )
+    end
+
+    it "supports hashes as dictionary values" do
+      schema.dictionary(:users) do
+        hash do
+          string :name
+          integer :age
+        end
+      end
+
+      expect(schema.fields[:users]).to eq(
+        {
+          type: :dictionary,
+          description: nil,
+          value_type: {
+            type: :hash,
+            description: nil,
+            fields: {
+              name: {
+                type: :string,
+                description: nil
+              },
+              age: {
+                type: :integer,
+                description: nil
+              }
+            }
+          }
+        }
+      )
+    end
+
+    it "supports arrays as dictionary values" do
+      schema.dictionary(:categories) { array { string } }
+
+      expect(schema.fields[:categories]).to eq(
+        {
+          type: :dictionary,
+          description: nil,
+          value_type: {
+            type: :array,
+            description: nil,
+            element_type: {
+              type: :string,
+              description: nil
+            }
+          }
+        }
+      )
+    end
   end
 
   describe "primitive types" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lluminary
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Doug Hughes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-24 00:00:00.000000000 Z
+date: 2025-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -241,6 +241,7 @@ files:
 - spec/examples/quote_task_spec.rb
 - spec/examples/sentiment_analysis_spec.rb
 - spec/examples/summarize_text_spec.rb
+- spec/examples/text_emotion_analyzer_spec.rb
 - spec/lluminary/config_spec.rb
 - spec/lluminary/models/base_spec.rb
 - spec/lluminary/models/bedrock/amazon_nova_pro_v1_spec.rb