lluminary 0.1.2 → 0.1.3

data/spec/lluminary/task_spec.rb

@@ -12,8 +12,6 @@ RSpec.describe Lluminary::Task do
         string :summary, description: "A brief summary of the message"
       end
 
-      private
-
       def task_prompt
         "Say: #{message}"
       end
@@ -30,67 +28,10 @@ RSpec.describe Lluminary::Task do
       )
     end
 
-    it "string input allows providing a string input" do
-      result = task_class.call(message: "hello")
-      expect(result.output.raw_response).to eq(
-        '{"summary": "Test string value"}'
-      )
-    end
-
     it "string output returns the output in the result" do
       result = task_class.call(message: "hello")
       expect(result.output.summary).to eq("Test string value")
     end
-
-    it "includes schema descriptions in the prompt" do
-      result = task_class.call(message: "hello")
-      expected_schema = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string): A brief summary of the message
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(result.prompt).to include(expected_schema.chomp)
-    end
-  end
-
-  describe ".call without descriptions" do
-    let(:task_without_descriptions) do
-      Class.new(described_class) do
-        input_schema { string :message }
-
-        output_schema { string :summary }
-
-        private
-
-        def task_prompt
-          "Say: #{message}"
-        end
-      end
-    end
-
-    it "includes basic schema in the prompt" do
-      result = task_without_descriptions.call(message: "hello")
-      expected_schema = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string)
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(result.prompt).to include(expected_schema.chomp)
-    end
   end
 
   describe ".provider" do
@@ -113,9 +54,25 @@ RSpec.describe Lluminary::Task do
     it "with :openai instantiates OpenAI provider with config" do
       task_class.use_provider(:openai, api_key: "test")
       expect(task_class.provider).to be_a(Lluminary::Providers::OpenAI)
-      expect(task_class.provider.config).to eq(
+      expect(task_class.provider.config).to include(
         api_key: "test",
-        model: "gpt-3.5-turbo"
+        model: Lluminary::Models::OpenAi::Gpt35Turbo
+      )
+    end
+
+    it "with :bedrock instantiates Bedrock provider with config" do
+      task_class.use_provider(
+        :bedrock,
+        access_key_id: "test",
+        secret_access_key: "test",
+        region: "us-east-1"
+      )
+      expect(task_class.provider).to be_a(Lluminary::Providers::Bedrock)
+      expect(task_class.provider.config).to include(
+        access_key_id: "test",
+        secret_access_key: "test",
+        region: "us-east-1",
+        model: Lluminary::Models::Bedrock::AnthropicClaudeInstantV1
       )
     end
 
@@ -127,487 +84,6 @@ RSpec.describe Lluminary::Task do
     end
   end
 
-  describe "#json_schema_example" do
-    it "generates a schema example with descriptions" do
-      task = task_class.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string): A brief summary of the message
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    it "generates a schema example with datetime field" do
-      task_with_datetime =
-        Class.new(described_class) do
-          input_schema { string :message }
-
-          output_schema do
-            datetime :start_time, description: "When the event starts"
-          end
-
-          private
-
-          def task_prompt
-            "Say: #{message}"
-          end
-        end
-
-      task = task_with_datetime.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        start_time (datetime in ISO8601 format): When the event starts
-        Example: "2024-01-01T12:00:00+00:00"
-
-        Your response must be ONLY this JSON object:
-        {
-          "start_time": "2024-01-01T12:00:00+00:00"
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    it "generates a schema example with boolean field" do
-      task_with_boolean =
-        Class.new(described_class) do
-          input_schema { string :message }
-
-          output_schema do
-            boolean :is_valid, description: "Whether the input is valid"
-          end
-
-          private
-
-          def task_prompt
-            "Say: #{message}"
-          end
-        end
-
-      task = task_with_boolean.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        is_valid (boolean): Whether the input is valid
-        Example: true
-
-        Your response must be ONLY this JSON object:
-        {
-          "is_valid": true
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    it "generates a schema example with float field" do
-      task_with_float =
-        Class.new(described_class) do
-          input_schema { string :message }
-
-          output_schema { float :score, description: "The confidence score" }
-
-          private
-
-          def task_prompt
-            "Say: #{message}"
-          end
-        end
-
-      task = task_with_float.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        score (float): The confidence score
-        Example: 0.0
-
-        Your response must be ONLY this JSON object:
-        {
-          "score": 0.0
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    it "generates a schema example without descriptions" do
-      task_without_descriptions =
-        Class.new(described_class) do
-          input_schema { string :message }
-
-          output_schema { string :summary }
-
-          private
-
-          def task_prompt
-            "Say: #{message}"
-          end
-        end
-
-      task = task_without_descriptions.new(message: "test")
-      expected_output = <<~SCHEMA
-        You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-        The JSON object must contain the following fields:
-
-        summary (string)
-        Example: "your summary here"
-
-        Your response must be ONLY this JSON object:
-        {
-          "summary": "your summary here"
-        }
-      SCHEMA
-      expect(task.send(:json_schema_example)).to eq(expected_output.chomp)
-    end
-
-    context "validation descriptions" do
-      context "presence validation" do
-        it "includes presence validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :name, description: "The person's name"
-                validates :name, presence: true
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "name (string): The person's name\nValidation: must be present\nExample: \"your name here\""
-          )
-        end
-      end
-
-      context "length validation" do
-        it "includes minimum length validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :name, description: "The person's name"
-                validates :name, length: { minimum: 2 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "name (string): The person's name\nValidation: must be at least 2 characters\nExample: \"your name here\""
-          )
-        end
-
-        it "includes maximum length validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :name, description: "The person's name"
-                validates :name, length: { maximum: 20 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "name (string): The person's name\nValidation: must be at most 20 characters\nExample: \"your name here\""
-          )
-        end
-
-        it "includes range length validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :password, description: "The password"
-                validates :password, length: { in: 8..20 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(<<~DESCRIPTION)
-              password (string): The password
-              Validation: must be between 8 and 20 characters
-              Example: "your password here"
-            DESCRIPTION
-        end
-
-        it "includes multiple length validations in description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :username, description: "The username"
-                validates :username, length: { minimum: 3, maximum: 20 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(<<~DESCRIPTION)
-              username (string): The username
-              Validation: must be at least 3 characters, must be at most 20 characters
-              Example: "your username here"
-            DESCRIPTION
-        end
-      end
-
-      context "numericality validation" do
-        it "includes odd validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                integer :number, description: "Odd number"
-                validates :number, numericality: { odd: true }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "number (integer): Odd number\nValidation: must be odd\nExample: 0"
-          )
-        end
-
-        it "includes equal to validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                integer :level, description: "Level"
-                validates :level, numericality: { equal_to: 5 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "level (integer): Level\nValidation: must be equal to 5\nExample: 0"
-          )
-        end
-
-        it "includes less than or equal to validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                integer :score, description: "Score"
-                validates :score, numericality: { less_than_or_equal_to: 100 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "score (integer): Score\nValidation: must be less than or equal to 100\nExample: 0"
-          )
-        end
-
-        it "includes other than validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                integer :value, description: "Value"
-                validates :value, numericality: { other_than: 0 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "value (integer): Value\nValidation: must be other than 0\nExample: 0"
-          )
-        end
-
-        it "includes in range validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                integer :rating, description: "Rating"
-                validates :rating, numericality: { in: 1..5 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "rating (integer): Rating\nValidation: must be in: 1, 2, 3, 4, 5\nExample: 0"
-          )
-        end
-
-        it "includes multiple numericality validations in description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                integer :score, description: "Score"
-                validates :score,
-                          numericality: {
-                            greater_than: 0,
-                            less_than_or_equal_to: 100
-                          }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "score (integer): Score\nValidation: must be greater than 0, must be less than or equal to 100\nExample: 0"
-          )
-        end
-
-        it "includes multiple comparison validations in description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                integer :age, description: "Age"
-                validates :age, comparison: { greater_than: 0, less_than: 120 }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "age (integer): Age\nValidation: must be greater than 0, must be less than 120\nExample: 0"
-          )
-        end
-      end
-
-      context "format validation" do
-        it "includes format validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :email, description: "Email address"
-                validates :email, format: { with: /\A[^@\s]+@[^@\s]+\z/ }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to eq(<<~SCHEMA.chomp)
-            You must respond with ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
-            The JSON object must contain the following fields:
-
-            email (string): Email address
-            Validation: must match format: (?-mix:\\A[^@\\s]+@[^@\\s]+\\z)
-            Example: "your email here"
-
-            Your response must be ONLY this JSON object:
-            {
-              "email": "your email here"
-            }
-          SCHEMA
-        end
-      end
-
-      context "inclusion validation" do
-        it "includes inclusion validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :role, description: "User role"
-                validates :role, inclusion: { in: %w[admin user guest] }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "role (string): User role\nValidation: must be one of: admin, user, guest\nExample: \"your role here\""
-          )
-        end
-      end
-
-      context "exclusion validation" do
-        it "includes exclusion validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :status, description: "Status"
-                validates :status, exclusion: { in: %w[banned blocked] }
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "status (string): Status\nValidation: must not be one of: banned, blocked\nExample: \"your status here\""
-          )
-        end
-      end
-
-      context "absence validation" do
-        it "includes absence validation description" do
-          task_class =
-            Class.new(described_class) do
-              output_schema do
-                string :deleted_at, description: "Deletion timestamp"
-                validates :deleted_at, absence: true
-              end
-
-              private
-
-              def task_prompt = "Test prompt"
-            end
-
-          task = task_class.new
-          expect(task.send(:json_schema_example)).to include(
-            "deleted_at (string): Deletion timestamp\nValidation: must be absent\nExample: \"your deleted_at here\""
-          )
-        end
-      end
-    end
-  end
-
   describe "#validate_input" do
     let(:task_with_types) do
       Class.new(described_class) do
@@ -617,8 +93,6 @@ RSpec.describe Lluminary::Task do
           datetime :start_time
         end
 
-        private
-
         def task_prompt
           "Test prompt"
         end
@@ -690,8 +164,6 @@ RSpec.describe Lluminary::Task do
           integer :word_count
         end
 
-        private
-
         def task_prompt
           "Test prompt"
         end
@@ -761,8 +233,6 @@ RSpec.describe Lluminary::Task do
           string :author, description: "The person who said the quote"
         end
 
-        private
-
         def task_prompt
           "Generate an inspirational quote and its author"
         end
@@ -792,8 +262,6 @@ RSpec.describe Lluminary::Task do
           datetime :event_time, description: "When the event occurred"
         end
 
-        private
-
         def task_prompt
           "Test prompt"
         end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ require "dotenv"
 Dotenv.load
 
 require "lluminary"
+require "pry-byebug"
 
 RSpec.configure do |config|
   config.before(:each) { Lluminary.reset_configuration }