lluminary 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '015093c0cffd9d6e752bfd3bd6b03b16fb3740f33f1e7b11285908a4be4f3317'
-  data.tar.gz: 4120b07419eee36bfe7d9b00cf2224ae35739ac21be9e31f3b45cb531e88b2f8
+  metadata.gz: 43ca21be47208b82183b4156be99d1e9816ea1013b2ee0c5258df158b0f4f2c1
+  data.tar.gz: 4f835024abc67bcd6bb9dd108fd49431eec6a152f168e31592b2d5317b982889
 SHA512:
-  metadata.gz: d7424d0cdfbace6684373aa11dbc3d73d5ae2e4b7dddcb2f28eff13d5ac07e5a69672fca7da7fed0ad02be92faceb45d80bc5d339906e584e5d2732584e6a0c9
-  data.tar.gz: e529bd7a10437c74240b8849880108268c43b6ff6312c047b0b4809b75c80d0e800cbe2d7dc51b7fea09bdf6acf1e4af716defdd9937bf81cce8eb1b4b3bb63b
+  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/models/google/gemini_20_flash.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lluminary
+  module Models
+    module Google
+      class Gemini20Flash < Lluminary::Models::Base
+        NAME = "gemini-2.0-flash"
+
+        def compatible_with?(provider_name)
+          provider_name == :google
+        end
+
+        def name
+          NAME
+        end
+      end
+    end
+  end
+end

data/lib/lluminary/providers/google.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "openai"
+require "json"
+require_relative "../provider_error"
+
+# This is a quick and dirty implementation of a provider that works with Google's AI studio.
+# It does not currently support vertex. Plans are to eventually create a separate gem similar
+# `gemini-ai` that can work with either AI studio or Vertex. For now, this just uses the
+# OpenAI compatible endpoint.
+module Lluminary
+  module Providers
+    class Google < Base
+      NAME = :google
+      DEFAULT_MODEL = Models::Google::Gemini20Flash
+
+      attr_reader :client, :config
+
+      def initialize(**config_overrides)
+        super
+        @config = { model: DEFAULT_MODEL }.merge(config)
+        @client =
+          ::OpenAI::Client.new(
+            access_token: config[:api_key],
+            api_version: "",
+            uri_base: "https://generativelanguage.googleapis.com/v1beta/openai"
+          )
+      end
+
+      def call(prompt, _task)
+        response =
+          client.chat(
+            parameters: {
+              model: model.class::NAME,
+              messages: [{ role: "user", content: prompt }],
+              response_format: {
+                type: "json_object"
+              }
+            }
+          )
+
+        content = response.dig("choices", 0, "message", "content")
+
+        {
+          raw: content,
+          parsed:
+            begin
+              JSON.parse(content) if content
+            rescue JSON::ParserError
+              nil
+            end
+        }
+      end
+
+      def model
+        @model ||= config[:model].new
+      end
+
+      def models
+        response = @client.models.list
+        response["data"].map { |model| model["id"].split("/").last }
+      end
+    end
+  end
+end

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/lib/lluminary/task.rb

@@ -3,9 +3,6 @@ require "ostruct"
 require "json"
 require_relative "schema"
 require_relative "validation_error"
-require_relative "models/base"
-require_relative "models/openai/gpt35_turbo"
-require_relative "models/bedrock/anthropic_claude_instant_v1"
 
 module Lluminary
   # Base class for all Lluminary tasks.
@@ -25,18 +22,21 @@ module Lluminary
       def use_provider(provider_name, **config)
         provider_class =
           case provider_name
+          when :anthropic
+            require_relative "providers/anthropic"
+            Providers::Anthropic
+          when :bedrock
+            require_relative "providers/bedrock"
+            Providers::Bedrock
+          when :google
+            require_relative "providers/google"
+            Providers::Google
           when :openai
             require_relative "providers/openai"
             Providers::OpenAI
           when :test
             require_relative "providers/test"
             Providers::Test
-          when :bedrock
-            require_relative "providers/bedrock"
-            Providers::Bedrock
-          when :anthropic
-            require_relative "providers/anthropic"
-            Providers::Anthropic
           else
             raise ArgumentError, "Unknown provider: #{provider_name}"
           end

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/models/google/gemini_20_flash_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lluminary::Models::Google::Gemini20Flash do
+  subject(:model) { described_class.new }
+
+  describe "#NAME" do
+    it "has the correct model name" do
+      expect(described_class::NAME).to eq("gemini-2.0-flash")
+    end
+  end
+
+  describe "#compatible_with?" do
+    it "returns true for google provider" do
+      expect(model.compatible_with?(:google)).to be true
+    end
+
+    it "returns false for other providers" do
+      expect(model.compatible_with?(:openai)).to be false
+      expect(model.compatible_with?(:bedrock)).to be false
+      expect(model.compatible_with?(:anthropic)).to be false
+    end
+  end
+
+  describe "#name" do
+    it "returns the model name" do
+      expect(model.name).to eq("gemini-2.0-flash")
+    end
+  end
+end

data/spec/lluminary/providers/google_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+RSpec.describe Lluminary::Providers::Google do
+  let(:config) { { api_key: "test-key" } }
+  let(:provider) { described_class.new(**config) }
+
+  describe "#client" do
+    it "returns the OpenAI client instance" do
+      expect(provider.client).to be_a(OpenAI::Client)
+    end
+  end
+
+  describe "#models" do
+    let(:mock_models_response) do
+      {
+        "object" => "list",
+        "data" => [
+          {
+            "id" => "models/gemini-2.0-flash",
+            "object" => "model",
+            "owned_by" => "google"
+          },
+          {
+            "id" => "models/gemini-1.5-pro",
+            "object" => "model",
+            "owned_by" => "google"
+          }
+        ]
+      }
+    end
+
+    before do
+      allow_any_instance_of(OpenAI::Client).to receive(:models).and_return(
+        double("ModelsClient", list: mock_models_response)
+      )
+    end
+
+    it "returns an array of model IDs as strings with the 'models/' prefix removed" do
+      expect(provider.models).to eq(%w[gemini-2.0-flash gemini-1.5-pro])
+    end
+  end
+
+  describe "#call" do
+    let(:prompt) { "Test prompt" }
+    let(:task) { "Test task" }
+    let(:mock_response) do
+      {
+        "choices" => [
+          { "message" => { "content" => '{"summary": "Test response"}' } }
+        ]
+      }
+    end
+
+    before do
+      allow_any_instance_of(OpenAI::Client).to receive(:chat).and_return(
+        mock_response
+      )
+    end
+
+    it "returns a hash with raw and parsed response" do
+      response = provider.call(prompt, task)
+      expect(response).to eq(
+        {
+          raw: '{"summary": "Test response"}',
+          parsed: {
+            "summary" => "Test response"
+          }
+        }
+      )
+    end
+
+    context "when the response is not valid JSON" do
+      let(:mock_response) do
+        { "choices" => [{ "message" => { "content" => "not valid json" } }] }
+      end
+
+      it "returns raw response with nil parsed value" do
+        response = provider.call(prompt, task)
+        expect(response).to eq({ raw: "not valid json", parsed: nil })
+      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.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Doug Hughes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-16 00:00:00.000000000 Z
+date: 2025-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -216,11 +216,13 @@ files:
 - lib/lluminary/models/bedrock/amazon_nova_pro_v1.rb
 - lib/lluminary/models/bedrock/anthropic_claude_instant_v1.rb
 - lib/lluminary/models/bedrock/base.rb
+- lib/lluminary/models/google/gemini_20_flash.rb
 - lib/lluminary/models/openai/gpt35_turbo.rb
 - lib/lluminary/provider_error.rb
 - lib/lluminary/providers/anthropic.rb
 - lib/lluminary/providers/base.rb
 - lib/lluminary/providers/bedrock.rb
+- lib/lluminary/providers/google.rb
 - lib/lluminary/providers/openai.rb
 - lib/lluminary/providers/test.rb
 - lib/lluminary/result.rb
@@ -239,13 +241,16 @@ 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
 - spec/lluminary/models/bedrock/anthropic_claude_instant_v1_spec.rb
+- spec/lluminary/models/google/gemini_20_flash_spec.rb
 - spec/lluminary/models/openai/gpt35_turbo_spec.rb
 - spec/lluminary/providers/anthropic_spec.rb
 - spec/lluminary/providers/bedrock_spec.rb
+- spec/lluminary/providers/google_spec.rb
 - spec/lluminary/providers/openai_spec.rb
 - spec/lluminary/providers/test_spec.rb
 - spec/lluminary/result_spec.rb