lluminary 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20a5892da2184571fc6e1a681fc5ed81143c87a5abafc745249b0a28d5ef4f3a
-  data.tar.gz: 984b6467b9ac1a82af4107efbd72a4ae14ab05cae8e3838120dd0252ea0a5dc0
+  metadata.gz: '015093c0cffd9d6e752bfd3bd6b03b16fb3740f33f1e7b11285908a4be4f3317'
+  data.tar.gz: 4120b07419eee36bfe7d9b00cf2224ae35739ac21be9e31f3b45cb531e88b2f8
 SHA512:
-  metadata.gz: 85ad7a6f048fc3bad3ca587a638da18e5026dce9a7f5068e551170c5531f26a1b5da83b6fe193339dbeae1eaf087d50283d96742e5f0ace04905a9eb8abb73b1
-  data.tar.gz: 0c501c6277d1b58114998b005b02d0a6ab10aec14ed8f21026d8c682a20c9d09692ee818cb24252c2befd88f99aa578fa4302b880d6f8ed67b05ae8b56b94b87
+  metadata.gz: d7424d0cdfbace6684373aa11dbc3d73d5ae2e4b7dddcb2f28eff13d5ac07e5a69672fca7da7fed0ad02be92faceb45d80bc5d339906e584e5d2732584e6a0c9
+  data.tar.gz: e529bd7a10437c74240b8849880108268c43b6ff6312c047b0b4809b75c80d0e800cbe2d7dc51b7fea09bdf6acf1e4af716defdd9937bf81cce8eb1b4b3bb63b

data/lib/lluminary/models/anthropic/claude_3_5_sonnet.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# require_relative "../base"
+
+module Lluminary
+  module Models
+    module Anthropic
+      class Claude35Sonnet < Lluminary::Models::Base
+        NAME = "claude-3-5-sonnet-latest"
+
+        def compatible_with?(provider_name)
+          provider_name == :anthropic
+        end
+      end
+    end
+  end
+end

data/lib/lluminary/models/base.rb

@@ -27,6 +27,8 @@ module Lluminary
           
           #{format_fields_descriptions(task.class.output_fields)}
           
+          #{format_additional_validations(task.class.output_custom_validations)}
+
           #{json_preamble}
           
           #{generate_example_json_object(task.class.output_fields)}
@@ -330,6 +332,15 @@ module Lluminary
           hash[subname] = generate_example_value(subname, subfield)
         end
       end
+
+      def format_additional_validations(custom_validations)
+        descriptions = custom_validations.map { |v| v[:description] }.compact
+        return "" if descriptions.empty?
+
+        section = ["Additional Validations:"]
+        descriptions.each { |desc| section << "- #{desc}" }
+        "#{section.join("\n")}\n"
+      end
     end
   end
 end

data/lib/lluminary/providers/anthropic.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "anthropic"
+require "json"
+require_relative "../provider_error"
+
+module Lluminary
+  module Providers
+    # Provider for Anthropic's models.
+    # Implements the Base provider interface for Anthropic's API.
+    class Anthropic < Base
+      NAME = :anthropic
+      DEFAULT_MODEL = Models::Anthropic::Claude35Sonnet
+
+      attr_reader :client, :config
+
+      def initialize(**config_overrides)
+        super
+        @config = { model: DEFAULT_MODEL }.merge(config)
+        @client = ::Anthropic::Client.new(api_key: config[:api_key])
+      end
+
+      def call(prompt, _task)
+        message =
+          client.messages.create(
+            max_tokens: 1024, # TODO: make this configurable
+            messages: [{ role: "user", content: prompt }],
+            model: model.class::NAME
+          )
+
+        content = message.content.first.text
+
+        {
+          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 }
+      end
+    end
+  end
+end

data/lib/lluminary/schema.rb

@@ -9,6 +9,7 @@ module Lluminary
     def initialize
       @fields = {}
       @validations = []
+      @custom_validations = []
     end
 
     def string(name, description: nil)
@@ -57,7 +58,7 @@ module Lluminary
       }
     end
 
-    attr_reader :fields
+    attr_reader :fields, :custom_validations
 
     def validates(*args, **options)
       @validations << [args, options]
@@ -72,18 +73,21 @@ module Lluminary
       end
     end
 
+    def validate(method_name, description: nil)
+      @custom_validations << { method: method_name, description: description }
+    end
+
     def validations_for(field_name)
       @validations.select { |args, _| args.include?(field_name) }
     end
 
     def schema_model
       @schema_model ||=
-        SchemaModel.build(fields: @fields, validations: @validations)
-    end
-
-    def validate(values)
-      instance = schema_model.new(values)
-      instance.valid? ? [] : instance.errors.full_messages
+        SchemaModel.build(
+          fields: @fields,
+          validations: @validations,
+          custom_validations: @custom_validations
+        )
     end
 
     # Internal class for defining array element types

data/lib/lluminary/schema_model.rb

@@ -8,6 +8,7 @@ module Lluminary
     include ActiveModel::Validations
 
     attr_reader :attributes
+    attr_accessor :task_instance
 
     def initialize(attributes = {})
       @attributes = attributes.transform_keys(&:to_s)
@@ -19,13 +20,14 @@ module Lluminary
       "#<#{self.class.name} #{attrs.inspect}>"
     end
 
-    def self.build(fields:, validations:)
+    def self.build(fields:, validations:, custom_validations: [])
       Class.new(self) do
         class << self
-          attr_accessor :schema_fields
+          attr_accessor :schema_fields, :custom_validation_methods
         end
 
         self.schema_fields = fields
+        self.custom_validation_methods = custom_validations
 
         # Add accessors for each field
         fields.each_key do |name|
@@ -39,7 +41,19 @@ module Lluminary
           @attributes["raw_response"] = value
         end
 
+        # Add custom validation hook
         validate do |record|
+          # Run custom validations from the task if present
+          if record.task_instance &&
+               !record.class.custom_validation_methods.empty?
+            record.class.custom_validation_methods.each do |validation|
+              method_name = validation[:method]
+              if record.task_instance.respond_to?(method_name)
+                record.task_instance.send(method_name)
+              end
+            end
+          end
+
           if record.raw_response
             begin
               JSON.parse(record.raw_response)

data/lib/lluminary/task.rb

@@ -34,6 +34,9 @@ module Lluminary
           when :bedrock
             require_relative "providers/bedrock"
             Providers::Bedrock
+          when :anthropic
+            require_relative "providers/anthropic"
+            Providers::Anthropic
           else
             raise ArgumentError, "Unknown provider: #{provider_name}"
           end
@@ -74,12 +77,23 @@ module Lluminary
       def output_schema_model
         @output_schema&.schema_model || Schema.new.schema_model
       end
+
+      def output_custom_validations
+        @output_schema&.custom_validations || []
+      end
+
+      def input_custom_validations
+        @input_schema&.custom_validations || []
+      end
     end
 
     attr_reader :input, :output, :parsed_response
+    attr_accessor :validation_failed
 
     def initialize(input = {})
       @input = self.class.input_schema_model.new(input)
+      @input.task_instance = self
+      @validation_failed = false
       define_input_methods
     end
 
@@ -120,8 +134,30 @@ module Lluminary
       raise NotImplementedError, "Subclasses must implement task_prompt"
     end
 
+    # Helper for validation methods to add errors
+    def errors
+      # Points to the current model being validated - used by custom validation methods
+      if @current_model == :output && @output
+        @output.errors
+      else
+        @input.errors
+      end
+    end
+
     private
 
+    def define_output_accessor_methods
+      return unless @output
+
+      # Define accessor methods for each output field
+      @output.attributes.each_key do |name|
+        next if name == "raw_response"
+        singleton_class.class_eval do
+          define_method(name) { @output.attributes[name.to_s] }
+        end
+      end
+    end
+
     def validate_input
       validate_input!
     end
@@ -129,6 +165,7 @@ module Lluminary
     def process_response(response)
       @parsed_response = response[:parsed]
       @output = self.class.output_schema_model.new
+      @output.task_instance = self
       @output.raw_response = response[:raw]
 
       # Merge the parsed response first, then validate
@@ -160,6 +197,9 @@ module Lluminary
         @output.attributes.merge!(converted_response)
       end
 
+      # Define methods to access output attributes directly in validation methods
+      define_output_accessor_methods
+
       # Validate after merging
       @output.valid?
 

data/lib/lluminary.rb

@@ -3,10 +3,16 @@
 require_relative "lluminary/version"
 require_relative "lluminary/result"
 require_relative "lluminary/task"
-# automatically require all providers
-Dir[File.join(__dir__, "lluminary/providers/*.rb")].each { |file| require file }
-# automatically require all models
+# require base model first
+require_relative "lluminary/models/base"
+# automatically require all models first
 Dir[File.join(__dir__, "lluminary/models/**/*.rb")].each { |file| require file }
+# require base provider first
+require_relative "lluminary/providers/base"
+# then require all other providers
+Dir[File.join(__dir__, "lluminary/providers/*.rb")].each do |file|
+  require file unless file.end_with?("base.rb")
+end
 require_relative "lluminary/config"
 
 # Lluminary is a framework for building and running LLM-powered tasks.

data/spec/lluminary/models/base_spec.rb

@@ -1035,6 +1035,38 @@ RSpec.describe Lluminary::Models::Base do
       end
     end
 
+    context "with custom validation descriptions" do
+      before do
+        task_class.output_schema do
+          string :name, description: "The person's name"
+          integer :confidence, description: "Confidence score from 0-100"
+          validate :validate_confidence_score,
+                   description: "Confidence score must be between 0 and 100"
+          validate :validate_other_thing, description: nil
+        end
+      end
+
+      it "includes an Additional Validations section with non-nil descriptions" do
+        prompt = model.format_prompt(task)
+        expect(prompt).to include("Additional Validations:")
+        expect(prompt).to include(
+          "- Confidence score must be between 0 and 100"
+        )
+        expect(prompt).not_to include("- \n") # Should not include a blank bullet for nil
+      end
+
+      it "omits Additional Validations section if all descriptions are nil" do
+        # Redefine schema with only nil descriptions
+        task_class.output_schema do
+          string :name, description: "The person's name"
+          validate :validate_confidence_score, description: nil
+          validate :validate_other_thing, description: nil
+        end
+        prompt = model.format_prompt(task)
+        expect(prompt).not_to include("Additional Validations:")
+      end
+    end
+
     context "JSON example generation" do
       context "with simple field types" do
         it "generates correct JSON example for string field" do

data/spec/lluminary/providers/anthropic_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+require "spec_helper"
+require "lluminary/providers/anthropic"
+
+RSpec.describe Lluminary::Providers::Anthropic do
+  let(:config) { { api_key: "test-key" } }
+  let(:provider) { described_class.new(**config) }
+
+  describe "#client" do
+    it "returns the Anthropic client instance" do
+      expect(provider.client).to be_a(Anthropic::Client)
+    end
+  end
+
+  describe "#models" do
+    let(:mock_models_response) do
+      mock_model_info_1 = double("ModelInfo", id: "claude-3-5-sonnet-latest")
+      mock_model_info_2 = double("ModelInfo", id: "claude-3-haiku-20240307")
+
+      double(
+        "Page",
+        data: [mock_model_info_1, mock_model_info_2],
+        has_more: false,
+        first_id: "claude-3-5-sonnet-latest",
+        last_id: "claude-3-haiku-20240307"
+      )
+    end
+
+    before do
+      models_client = double("ModelsClient")
+      allow_any_instance_of(Anthropic::Client).to receive(:models).and_return(
+        models_client
+      )
+      allow(models_client).to receive(:list).and_return(mock_models_response)
+    end
+
+    it "returns an array of model IDs as strings" do
+      expect(provider.models).to eq(
+        %w[claude-3-5-sonnet-latest claude-3-haiku-20240307]
+      )
+    end
+  end
+
+  describe "#call" do
+    let(:prompt) { "Test prompt" }
+    let(:task) { "Test task" }
+    let(:mock_response) do
+      OpenStruct.new(
+        content: [OpenStruct.new(text: '{"summary": "Test response"}')]
+      )
+    end
+
+    before do
+      messages_client = double("MessagesClient")
+      allow_any_instance_of(Anthropic::Client).to receive(:messages).and_return(
+        messages_client
+      )
+      allow(messages_client).to receive(:create).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
+        OpenStruct.new(content: [OpenStruct.new(text: "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
+
+  describe "#model" do
+    it "returns the default model when not specified" do
+      expect(provider.model).to be_a(
+        Lluminary::Models::Anthropic::Claude35Sonnet
+      )
+    end
+
+    it "returns the specified model when provided in config" do
+      model_class = double("ModelClass")
+      model_instance = double("ModelInstance")
+
+      allow(model_class).to receive(:new).and_return(model_instance)
+
+      custom_provider =
+        described_class.new(model: model_class, api_key: "test-key")
+
+      expect(custom_provider.model).to eq(model_instance)
+    end
+  end
+end