lluminary 0.1.1 → 0.1.3

data/spec/lluminary/providers/bedrock_spec.rb

@@ -1,109 +1,138 @@
-require 'spec_helper'
-require 'lluminary/providers/bedrock'
+# frozen_string_literal: true
+require "spec_helper"
+require "lluminary/providers/bedrock"
 
 RSpec.describe Lluminary::Providers::Bedrock do
   let(:config) do
     {
-      region: 'us-east-1',
-      access_key_id: 'test-key',
-      secret_access_key: 'test-secret'
+      region: "us-east-1",
+      access_key_id: "test-key",
+      secret_access_key: "test-secret"
     }
   end
   let(:provider) { described_class.new(**config) }
 
-  describe '#client' do
-    it 'returns the AWS Bedrock client instance' do
+  describe "#client" do
+    it "returns the AWS Bedrock client instance" do
       expect(provider.client).to be_a(Aws::BedrockRuntime::Client)
     end
   end
 
-  describe '#call' do
-    let(:prompt) { 'Test prompt' }
-    let(:task) { 'Test task' }
+  describe "#models" do
+    let(:mock_models_response) do
+      OpenStruct.new(
+        foundation_models: [
+          OpenStruct.new(
+            model_id: "anthropic.claude-instant-v1",
+            model_name: "Claude Instant",
+            provider_name: "Anthropic",
+            input_modalities: ["TEXT"],
+            output_modalities: ["TEXT"],
+            customizations_supported: []
+          ),
+          OpenStruct.new(
+            model_id: "anthropic.claude-v2",
+            model_name: "Claude V2",
+            provider_name: "Anthropic",
+            input_modalities: ["TEXT"],
+            output_modalities: ["TEXT"],
+            customizations_supported: []
+          )
+        ]
+      )
+    end
+
+    before do
+      models_client = double("BedrockClient")
+      allow(Aws::Bedrock::Client).to receive(:new).and_return(models_client)
+      allow(models_client).to receive(:list_foundation_models).and_return(
+        mock_models_response
+      )
+    end
+
+    it "returns an array of model IDs as strings" do
+      expect(provider.models).to eq(
+        %w[anthropic.claude-instant-v1 anthropic.claude-v2]
+      )
+    end
+  end
+
+  describe "#call" do
+    let(:prompt) { "Test prompt" }
+    let(:task) { "Test task" }
     let(:mock_response) do
       OpenStruct.new(
-        output: OpenStruct.new(
-          message: OpenStruct.new(
-            content: [
-              OpenStruct.new(text: '{"sentiment": "positive"}')
-            ]
+        output:
+          OpenStruct.new(
+            message:
+              OpenStruct.new(
+                content: [OpenStruct.new(text: '{"sentiment": "positive"}')]
+              )
           )
-        )
       )
     end
 
     before do
-      allow_any_instance_of(Aws::BedrockRuntime::Client).to receive(:converse).and_return(mock_response)
+      allow_any_instance_of(Aws::BedrockRuntime::Client).to receive(
+        :converse
+      ).and_return(mock_response)
     end
 
-    it 'returns a hash with raw and parsed response' do
+    it "returns a hash with raw and parsed response" do
       response = provider.call(prompt, task)
-      expect(response).to eq({
-        raw: '{"sentiment": "positive"}',
-        parsed: { 'sentiment' => 'positive' }
-      })
+      expect(response).to eq(
+        {
+          raw: '{"sentiment": "positive"}',
+          parsed: {
+            "sentiment" => "positive"
+          }
+        }
+      )
     end
 
-    context 'when the response is not valid JSON' do
+    context "when the response is not valid JSON" do
       let(:mock_response) do
         OpenStruct.new(
-          output: OpenStruct.new(
-            message: OpenStruct.new(
-              content: [
-                OpenStruct.new(text: 'not valid json')
-              ]
+          output:
+            OpenStruct.new(
+              message:
+                OpenStruct.new(
+                  content: [OpenStruct.new(text: "not valid json")]
+                )
             )
-          )
         )
       end
 
-      it 'returns raw response with nil parsed value' do
+      it "returns raw response with nil parsed value" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: 'not valid json',
-          parsed: nil
-        })
+        expect(response).to eq({ raw: "not valid json", parsed: nil })
       end
     end
 
-    context 'when the response content is nil' do
+    context "when the response content is nil" do
       let(:mock_response) do
         OpenStruct.new(
-          output: OpenStruct.new(
-            message: OpenStruct.new(
-              content: nil
-            )
-          )
+          output: OpenStruct.new(message: OpenStruct.new(content: nil))
         )
       end
 
-      it 'returns nil for both raw and parsed values' do
+      it "returns nil for both raw and parsed values" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: nil,
-          parsed: nil
-        })
+        expect(response).to eq({ raw: nil, parsed: nil })
       end
     end
 
-    context 'when the response content array is empty' do
+    context "when the response content array is empty" do
       let(:mock_response) do
         OpenStruct.new(
-          output: OpenStruct.new(
-            message: OpenStruct.new(
-              content: []
-            )
-          )
+          output: OpenStruct.new(message: OpenStruct.new(content: []))
         )
       end
 
-      it 'returns nil for both raw and parsed values' do
+      it "returns nil for both raw and parsed values" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: nil,
-          parsed: nil
-        })
+        expect(response).to eq({ raw: nil, parsed: nil })
       end
     end
   end
-end 
+end

data/spec/lluminary/providers/openai_spec.rb

@@ -1,62 +1,86 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
 RSpec.describe Lluminary::Providers::OpenAI do
-  let(:config) { { api_key: 'test-key' } }
+  let(:config) { { api_key: "test-key" } }
   let(:provider) { described_class.new(**config) }
 
-  describe '#client' do
-    it 'returns the OpenAI client instance' do
+  describe "#client" do
+    it "returns the OpenAI client instance" do
       expect(provider.client).to be_a(OpenAI::Client)
     end
   end
 
-  describe '#call' do
-    let(:prompt) { 'Test prompt' }
-    let(:task) { 'Test task' }
-    let(:mock_response) do
+  describe "#models" do
+    let(:mock_models_response) do
       {
-        'choices' => [
+        "object" => "list",
+        "data" => [
+          {
+            "id" => "gpt-4",
+            "object" => "model",
+            "created" => 1_687_882_411,
+            "owned_by" => "openai"
+          },
           {
-            'message' => {
-              'content' => '{"summary": "Test response"}'
-            }
+            "id" => "gpt-3.5-turbo",
+            "object" => "model",
+            "created" => 1_677_610_602,
+            "owned_by" => "openai"
           }
         ]
       }
     end
 
     before do
-      allow_any_instance_of(OpenAI::Client).to receive(:chat).and_return(mock_response)
+      allow_any_instance_of(OpenAI::Client).to receive(:models).and_return(
+        double("ModelsClient", list: mock_models_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' }
-      })
+    it "returns an array of model IDs as strings" do
+      expect(provider.models).to eq(%w[gpt-4 gpt-3.5-turbo])
     end
+  end
 
-    context 'when the response is not valid JSON' do
-      let(:mock_response) do
+  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(
         {
-          'choices' => [
-            {
-              'message' => {
-                'content' => 'not valid json'
-              }
-            }
-          ]
+          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
+      it "returns raw response with nil parsed value" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: 'not valid json',
-          parsed: nil
-        })
+        expect(response).to eq({ raw: "not valid json", parsed: nil })
       end
     end
   end
-end 
+end

data/spec/lluminary/providers/test_spec.rb

@@ -1,14 +1,42 @@
-require 'spec_helper'
-require 'lluminary/providers/test'
+# frozen_string_literal: true
+require "spec_helper"
+require "lluminary/providers/test"
 
 RSpec.describe Lluminary::Providers::Test do
   let(:provider) { described_class.new }
   let(:prompt) { "Test prompt" }
-  let(:task_class) { double("TaskClass", output_fields: { summary: { type: :string } }) }
+  let(:task_class) do
+    double("TaskClass", output_fields: { summary: { type: :string } })
+  end
   let(:task) { double("Task", class: task_class) }
 
-  describe '#call' do
-    it 'returns a hash with raw and parsed response' do
+  describe "#initialize" do
+    it "accepts configuration options" do
+      config = { api_key: "test_key", model: "test_model" }
+      provider = described_class.new(**config)
+      expect(provider.config).to eq(config)
+    end
+
+    it "merges default provider configuration with instance configuration" do
+      # Set up default provider configuration
+      Lluminary.configure do |config|
+        config.provider(:test, api_key: "global_key", model: "global_model")
+      end
+
+      # Create provider with instance-specific config
+      provider = described_class.new(model: "instance_model", temperature: 0.7)
+
+      # Should merge default and instance config, with instance taking precedence
+      expect(provider.config).to eq(
+        api_key: "global_key",
+        model: "instance_model",
+        temperature: 0.7
+      )
+    end
+  end
+
+  describe "#call" do
+    it "returns a hash with raw and parsed response" do
       response = provider.call(prompt, task)
 
       expect(response).to be_a(Hash)
@@ -16,7 +44,7 @@ RSpec.describe Lluminary::Providers::Test do
       expect(response[:parsed]).to eq({ "summary" => "Test string value" })
     end
 
-    it 'handles prompts with schema descriptions' do
+    it "handles prompts with schema descriptions" do
       prompt_with_schema = <<~PROMPT
         Test prompt
 
@@ -36,22 +64,24 @@ RSpec.describe Lluminary::Providers::Test do
       expect(response[:parsed]).to eq({ "summary" => "Test string value" })
     end
 
-    it 'generates integer values for integer fields' do
-      task_class = double("TaskClass", output_fields: { count: { type: :integer } })
+    it "generates integer values for integer fields" do
+      task_class =
+        double("TaskClass", output_fields: { count: { type: :integer } })
       task = double("Task", class: task_class)
-      
+
       response = provider.call(prompt, task)
       expect(response[:raw]).to eq('{"count": 0}')
       expect(response[:parsed]).to eq({ "count" => 0 })
     end
 
-    it 'raises error for unsupported types' do
-      task_class = double("TaskClass", output_fields: { value: { type: :unsupported } })
+    it "raises error for unsupported types" do
+      task_class =
+        double("TaskClass", output_fields: { value: { type: :unsupported } })
       task = double("Task", class: task_class)
-      
-      expect {
-        provider.call(prompt, task)
-      }.to raise_error("Unsupported type: unsupported")
+
+      expect { provider.call(prompt, task) }.to raise_error(
+        "Unsupported type: unsupported"
+      )
     end
   end
-end 
+end

data/spec/lluminary/result_spec.rb

@@ -1,31 +1,38 @@
-require 'lluminary'
+# frozen_string_literal: true
+require "lluminary"
 
 RSpec.describe Lluminary::Result do
   let(:raw_response) { "Test response" }
   let(:output) { { summary: "Test summary" } }
   let(:prompt) { "Test prompt" }
-  let(:result) { described_class.new(raw_response: raw_response, output: output, prompt: prompt) }
+  let(:result) do
+    described_class.new(
+      raw_response: raw_response,
+      output: output,
+      prompt: prompt
+    )
+  end
 
-  describe '#raw_response' do
-    it 'returns the raw response' do
+  describe "#raw_response" do
+    it "returns the raw response" do
       expect(result.raw_response).to eq(raw_response)
     end
   end
 
-  describe '#output' do
-    it 'returns an OpenStruct with the output data' do
+  describe "#output" do
+    it "returns an OpenStruct with the output data" do
       expect(result.output).to be_a(OpenStruct)
       expect(result.output.summary).to eq(output[:summary])
     end
 
-    it 'allows accessing output fields as methods' do
+    it "allows accessing output fields as methods" do
       expect(result.output.summary).to eq(output[:summary])
     end
   end
 
-  describe '#prompt' do
-    it 'returns the prompt' do
+  describe "#prompt" do
+    it "returns the prompt" do
       expect(result.prompt).to eq(prompt)
     end
   end
-end 
+end

data/spec/lluminary/schema_model_spec.rb

@@ -1,11 +1,18 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
 RSpec.describe Lluminary::SchemaModel do
-  describe '.build' do
+  describe ".build" do
     let(:fields) do
       {
-        name: { type: :string, description: "The user's name" },
-        age: { type: :integer, description: "The user's age" }
+        name: {
+          type: :string,
+          description: "The user's name"
+        },
+        age: {
+          type: :integer,
+          description: "The user's age"
+        }
       }
     end
 
@@ -16,35 +23,39 @@ RSpec.describe Lluminary::SchemaModel do
       ]
     end
 
-    let(:model_class) { described_class.build(fields: fields, validations: validations) }
+    let(:model_class) do
+      described_class.build(fields: fields, validations: validations)
+    end
 
-    it 'creates a class that inherits from SchemaModel' do
+    it "creates a class that inherits from SchemaModel" do
       expect(model_class.ancestors).to include(described_class)
     end
 
-    it 'includes ActiveModel::Validations' do
+    it "includes ActiveModel::Validations" do
       expect(model_class.ancestors).to include(ActiveModel::Validations)
     end
 
-    it 'adds accessors for fields' do
+    it "adds accessors for fields" do
       instance = model_class.new(name: "John", age: 30)
       expect(instance.name).to eq("John")
       expect(instance.age).to eq(30)
     end
 
-    it 'validates presence' do
+    it "validates presence" do
       instance = model_class.new(age: 30)
       expect(instance.valid?).to be false
       expect(instance.errors.full_messages).to include("Name can't be blank")
     end
 
-    it 'validates numericality' do
+    it "validates numericality" do
       instance = model_class.new(name: "John", age: 0)
       expect(instance.valid?).to be false
-      expect(instance.errors.full_messages).to include("Age must be greater than 0")
+      expect(instance.errors.full_messages).to include(
+        "Age must be greater than 0"
+      )
     end
 
-    it 'validates types' do
+    it "validates types" do
       instance = model_class.new(name: 123, age: "30")
       expect(instance.valid?).to be false
       expect(instance.errors.full_messages).to include(
@@ -53,34 +64,109 @@ RSpec.describe Lluminary::SchemaModel do
       )
     end
 
-    it 'validates float types' do
-      fields = {
-        price: { type: :float, description: "The price" }
-      }
+    it "validates float types" do
+      fields = { price: { type: :float, description: "The price" } }
       model_class = described_class.build(fields: fields, validations: [])
-      
+
       # Test that nil is allowed
       instance = model_class.new(price: nil)
       expect(instance.valid?).to be true
-      
+
       # Test invalid float value
       instance = model_class.new(price: "not a float")
       expect(instance.valid?).to be false
       expect(instance.errors.full_messages).to include("Price must be a float")
-      
+
       # Test valid float value
       instance = model_class.new(price: 12.34)
       expect(instance.valid?).to be true
     end
 
-    it 'accepts valid attributes' do
+    it "accepts valid attributes" do
       instance = model_class.new(name: "John", age: 30)
       expect(instance.valid?).to be true
     end
 
-    it 'provides access to raw attributes' do
+    it "provides access to raw attributes" do
       instance = model_class.new(name: "John", age: 30)
       expect(instance.attributes).to eq({ "name" => "John", "age" => 30 })
     end
+
+    it "validates array types" do
+      fields = {
+        items: {
+          type: :array,
+          element_type: {
+            type: :string,
+            description: nil
+          },
+          description: "A list of strings"
+        }
+      }
+      model_class = described_class.build(fields: fields, validations: [])
+
+      # Test that nil is allowed
+      instance = model_class.new(items: nil)
+      expect(instance.valid?).to be true
+
+      # Test valid array of strings
+      instance = model_class.new(items: %w[one two])
+      expect(instance.valid?).to be true
+
+      # Test invalid array (not an array)
+      instance = model_class.new(items: "not an array")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include("Items must be an Array")
+
+      # Test invalid array elements
+      instance = model_class.new(items: ["one", 2, "three"])
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Items[1] must be a String"
+      )
+    end
+
+    it "validates nested array types" do
+      fields = {
+        matrix: {
+          type: :array,
+          element_type: {
+            type: :array,
+            element_type: {
+              type: :integer,
+              description: nil
+            },
+            description: nil
+          },
+          description: "A matrix of integers"
+        }
+      }
+      model_class = described_class.build(fields: fields, validations: [])
+
+      # Test valid nested arrays
+      instance = model_class.new(matrix: [[1, 2], [3, 4]])
+      expect(instance.valid?).to be true
+
+      # Test invalid outer array
+      instance = model_class.new(matrix: "not an array")
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Matrix must be an Array"
+      )
+
+      # Test invalid inner array
+      instance = model_class.new(matrix: ["not an array"])
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Matrix[0] must be an Array"
+      )
+
+      # Test invalid inner array elements
+      instance = model_class.new(matrix: [[1, "2"], [3, 4]])
+      expect(instance.valid?).to be false
+      expect(instance.errors.full_messages).to include(
+        "Matrix[0][1] must be an Integer"
+      )
+    end
   end
-end 
+end