lluminary 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd0178afb0e59f3bf23029641e37f9ed149a7a3fadcdf364a88ad9079c8adc7d
-  data.tar.gz: 4fe96f29859d3f55104d977ca81df4e41ff450c1e37a3a880f7af3f574bf8037
+  metadata.gz: 77729a2c4dc59717c0fd5c8fa8cf21df682bbaeff5c66e501f0e409cb8ac16c4
+  data.tar.gz: 46aa2188fcad140a7e7dfa2cc3d4bd5008d1bd5afbf70920bc3b211eb9018480
 SHA512:
-  metadata.gz: 33ec5d4bd8e00d43dca677aafd076f6de386859c14fb0b001b962032ca0a455fdd2c36e5755e6d898ee54a1bbc4f64714c1ea7b9d7774330a25478c4698c8759
-  data.tar.gz: 99c318f93c98a31b1c171436db63609b3258ed183c7e9fc73f16c7f0eb8c09a5eb3d5d1c4e548232e10c2b40956d13b31efae5a0582bb35d91b19d315d667a06
+  metadata.gz: ed78898c62ab28d52136d470f5ccf398b3d5dcce8643af51348834877b3561ae3ca5b0ca1e7d12fbab6d0a8b677e7599c393dd9f678af970da5d3d5f01da9e24
+  data.tar.gz: 961371925c55006aedfe7b89d043aa10411f90b26fe1c67be356c2b81ebcc618417eb0fa1ff1cdf5dcd7344adb0e75b208d82e0ae256e0497c178c6f6d3569f9

data/lib/lluminary/config.rb

@@ -3,12 +3,7 @@
 module Lluminary
   # Configuration class for Lluminary framework.
   # Handles global settings and provider configurations.
-  #
-  # @example Setting up configuration
-  #   Lluminary.configure do |config|
-  #     config.provider = :openai
-  #     config.api_key = "your-api-key"
-  #   end
+
   class Config
     def initialize
       @providers = {}

data/lib/lluminary/models/base.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Lluminary
+  module Models
+    # Base class for all LLM models.
+    # Defines the interface that all model classes must implement and provides
+    # default prompt formatting behavior.
+    class Base
+      # Checks if this model is compatible with a given provider
+      # @param provider_name [Symbol] The name of the provider to check
+      # @return [Boolean]
+      def compatible_with?(provider_name)
+        raise NotImplementedError, "Subclasses must implement #compatible_with?"
+      end
+
+      # Returns the name of the model
+      # @return [String]
+      def name
+        raise NotImplementedError, "Subclasses must implement #name"
+      end
+
+      def format_prompt(task)
+        <<~PROMPT
+          #{task.task_prompt.chomp}
+
+          #{output_preamble}
+          
+          #{format_field_descriptions(task.class.output_fields)}
+          
+          #{json_preamble}
+          
+          #{format_json_example(task.class.output_fields)}
+        PROMPT
+      end
+
+      private
+
+      def output_preamble
+        <<~PREAMBLE.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:
+        PREAMBLE
+      end
+
+      def json_preamble
+        "Your response must be ONLY this JSON object:"
+      end
+
+      def format_field_descriptions(fields)
+        fields
+          .map do |name, field|
+            desc = "# #{name}"
+            desc += "\nType: #{format_type(field)}"
+
+            desc += "\nDescription: #{field[:description].chomp}" if field[
+              :description
+            ]
+
+            if (validations = describe_validations(field[:validations]))
+              desc += "\nValidations: #{validations}"
+            end
+
+            desc += "\nExample: #{generate_example_value(name, field)}"
+            desc
+          end
+          .join("\n\n")
+      end
+
+      def describe_validations(validations)
+        return unless validations&.any?
+
+        validations
+          .map do |options|
+            case options.keys.first
+            when :presence
+              "must be present"
+            when :inclusion
+              "must be one of: #{options[:inclusion][:in].join(", ")}"
+            when :exclusion
+              "must not be one of: #{options[:exclusion][:in].join(", ")}"
+            when :format
+              "must match format: #{options[:format][:with]}"
+            when :length
+              describe_length_validation(options[:length])
+            when :numericality
+              describe_numericality_validation(options[:numericality])
+            when :comparison
+              describe_comparison_validation(options[:comparison])
+            when :absence
+              "must be absent"
+            end
+          end
+          .compact
+          .join(", ")
+      end
+
+      def describe_length_validation(options)
+        descriptions = []
+        if options[:minimum]
+          descriptions << "must be at least #{options[:minimum]} characters"
+        end
+        if options[:maximum]
+          descriptions << "must be at most #{options[:maximum]} characters"
+        end
+        if options[:is]
+          descriptions << "must be exactly #{options[:is]} characters"
+        end
+        if options[:in]
+          descriptions << "must be between #{options[:in].min} and #{options[:in].max} characters"
+        end
+        descriptions.join(", ")
+      end
+
+      def describe_numericality_validation(options)
+        descriptions = []
+        if options[:greater_than]
+          descriptions << "must be greater than #{options[:greater_than]}"
+        end
+        if options[:greater_than_or_equal_to]
+          descriptions << "must be greater than or equal to #{options[:greater_than_or_equal_to]}"
+        end
+        if options[:equal_to]
+          descriptions << "must be equal to #{options[:equal_to]}"
+        end
+        if options[:less_than]
+          descriptions << "must be less than #{options[:less_than]}"
+        end
+        if options[:less_than_or_equal_to]
+          descriptions << "must be less than or equal to #{options[:less_than_or_equal_to]}"
+        end
+        if options[:other_than]
+          descriptions << "must be other than #{options[:other_than]}"
+        end
+        if options[:in]
+          descriptions << "must be in: #{options[:in].to_a.join(", ")}"
+        end
+        descriptions << "must be odd" if options[:odd]
+        descriptions << "must be even" if options[:even]
+        descriptions.join(", ")
+      end
+
+      def describe_comparison_validation(options)
+        descriptions = []
+        if options[:greater_than]
+          descriptions << "must be greater than #{options[:greater_than]}"
+        end
+        if options[:greater_than_or_equal_to]
+          descriptions << "must be greater than or equal to #{options[:greater_than_or_equal_to]}"
+        end
+        if options[:equal_to]
+          descriptions << "must be equal to #{options[:equal_to]}"
+        end
+        if options[:less_than]
+          descriptions << "must be less than #{options[:less_than]}"
+        end
+        if options[:less_than_or_equal_to]
+          descriptions << "must be less than or equal to #{options[:less_than_or_equal_to]}"
+        end
+        if options[:other_than]
+          descriptions << "must be other than #{options[:other_than]}"
+        end
+        descriptions.join(", ")
+      end
+
+      def format_json_example(fields)
+        example =
+          fields.each_with_object({}) do |(name, field), hash|
+            hash[name] = generate_example_value(name, field)
+          end
+        JSON.pretty_generate(example)
+      end
+
+      def format_type(field)
+        type = field[:type]
+        case type
+        when :datetime
+          "datetime in ISO8601 format"
+        when :array
+          if field[:element_type]
+            "array of #{format_type(field[:element_type])}"
+          else
+            "array"
+          end
+        else
+          type.to_s
+        end
+      end
+
+      def generate_example_value(name, field)
+        case field[:type]
+        when :string
+          "your #{name} here"
+        when :integer
+          0
+        when :datetime
+          "2024-01-01T12:00:00+00:00"
+        when :boolean
+          true
+        when :float
+          0.0
+        when :array
+          generate_array_example(name, field)
+        end
+      end
+
+      def generate_array_example(name, field)
+        return [] unless field[:element_type]
+
+        case field[:element_type][:type]
+        when :string
+          [
+            "first #{name.to_s.singularize}",
+            "second #{name.to_s.singularize}",
+            "..."
+          ]
+        when :integer
+          [1, 2, 3]
+        when :float
+          [1.0, 2.0, 3.0]
+        when :boolean
+          [true, false, true]
+        when :datetime
+          %w[2024-01-01T12:00:00+00:00 2024-01-02T12:00:00+00:00]
+        when :array
+          if field[:element_type][:element_type]
+            inner_example = generate_array_example("item", field[:element_type])
+            [inner_example, inner_example]
+          else
+            [["..."], ["..."]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lluminary/models/bedrock/amazon_nova_pro_v1.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Lluminary
+  module Models
+    module Bedrock
+      class AmazonNovaProV1 < Lluminary::Models::Bedrock::Base
+        NAME = "amazon.nova-pro-v1"
+        VERSIONS = %w[0].freeze
+        CONTEXT_WINDOWS = %w[24k 300k].freeze
+
+        def compatible_with?(provider_name)
+          provider_name == :bedrock
+        end
+      end
+    end
+  end
+end

data/lib/lluminary/models/bedrock/anthropic_claude_instant_v1.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Lluminary
+  module Models
+    module Bedrock
+      class AnthropicClaudeInstantV1 < Lluminary::Models::Bedrock::Base
+        NAME = "anthropic.claude-instant-v1"
+
+        def compatible_with?(provider_name)
+          provider_name == :bedrock
+        end
+      end
+    end
+  end
+end

data/lib/lluminary/models/bedrock/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lluminary
+  module Models
+    module Bedrock
+      # TODO: test me
+      class Base < Lluminary::Models::Base
+        VERSIONS = [].freeze
+        CONTEXT_WINDOWS = [].freeze
+
+        def default_version
+          self.class::VERSIONS.last
+        end
+
+        def default_context_window
+          nil
+        end
+
+        def name
+          [
+            self.class::NAME,
+            default_version,
+            default_context_window
+          ].compact.join(":")
+        end
+      end
+    end
+  end
+end

data/lib/lluminary/models/openai/gpt35_turbo.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lluminary
+  module Models
+    module OpenAi
+      # Model class for OpenAI's GPT-3.5 Turbo
+      class Gpt35Turbo < Base
+        NAME = "gpt-3.5-turbo"
+
+        def compatible_with?(provider_name)
+          provider_name == :openai
+        end
+
+        def name
+          NAME
+        end
+      end
+    end
+  end
+end

data/lib/lluminary/providers/base.rb

@@ -5,15 +5,28 @@ module Lluminary
     # Base class for all LLM providers.
     # Defines the interface that all providers must implement.
     class Base
+      # The symbolic name of the provider. Must be overridden by subclasses.
+      NAME = :base
+
       attr_reader :config
 
-      def initialize(**config)
-        @config = config
+      def initialize(**config_overrides)
+        @config = default_provider_config.merge(config_overrides)
       end
 
       def call(prompt, task)
         raise NotImplementedError, "Subclasses must implement #call"
       end
+
+      def models
+        raise NotImplementedError, "Subclasses must implement #models"
+      end
+
+      private
+
+      def default_provider_config
+        Lluminary.config.provider_config(self.class::NAME)
+      end
     end
   end
 end

data/lib/lluminary/providers/bedrock.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 require "aws-sdk-bedrockruntime"
+require "aws-sdk-bedrock"
 require "json"
 require_relative "../provider_error"
 
-require "pry-byebug"
-
 module Lluminary
   module Providers
     # Provider for AWS Bedrock models.
     # Implements the Base provider interface for AWS Bedrock's API.
     class Bedrock < Base
-      DEFAULT_MODEL_ID = "anthropic.claude-instant-v1"
+      NAME = :bedrock
+      DEFAULT_MODEL = Models::Bedrock::AnthropicClaudeInstantV1
 
       attr_reader :client, :config
 
-      def initialize(**config)
+      def initialize(**config_overrides)
         super
-        @config = { model_id: DEFAULT_MODEL_ID }.merge(config)
+        @config = { model: DEFAULT_MODEL }.merge(config)
 
         @client =
           Aws::BedrockRuntime::Client.new(
@@ -31,8 +31,8 @@ module Lluminary
 
       def call(prompt, _task)
         response =
-          @client.converse(
-            model_id: config[:model_id],
+          client.converse(
+            model_id: model.name,
             messages: [{ role: "user", content: [{ text: prompt }] }]
           )
 
@@ -48,6 +48,24 @@ module Lluminary
             end
         }
       end
+
+      def model
+        @model ||= config[:model].new
+      end
+
+      def models
+        models_client =
+          Aws::Bedrock::Client.new(
+            region: config[:region],
+            credentials:
+              Aws::Credentials.new(
+                config[:access_key_id],
+                config[:secret_access_key]
+              )
+          )
+        response = models_client.list_foundation_models
+        response.foundation_models.map(&:model_id)
+      end
     end
   end
 end

data/lib/lluminary/providers/openai.rb

@@ -8,11 +8,12 @@ module Lluminary
     # Provider for OpenAI's GPT models.
     # Implements the Base provider interface for OpenAI's API.
     class OpenAI < Base
-      DEFAULT_MODEL = "gpt-3.5-turbo"
+      NAME = :openai
+      DEFAULT_MODEL = Models::OpenAi::Gpt35Turbo
 
       attr_reader :client, :config
 
-      def initialize(**config)
+      def initialize(**config_overrides)
         super
         @config = { model: DEFAULT_MODEL }.merge(config)
         @client = ::OpenAI::Client.new(access_token: config[:api_key])
@@ -20,9 +21,9 @@ module Lluminary
 
       def call(prompt, _task)
         response =
-          @client.chat(
+          client.chat(
             parameters: {
-              model: config[:model],
+              model: model.class::NAME,
               messages: [{ role: "user", content: prompt }],
               response_format: {
                 type: "json_object"
@@ -42,6 +43,15 @@ module Lluminary
             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/providers/test.rb

@@ -5,12 +5,18 @@ module Lluminary
     # Test provider for development and testing.
     # Returns predefined responses for testing purposes.
     class Test < Base
+      NAME = :test
+
       def call(_prompt, task)
         response = generate_response(task.class.output_fields)
         raw_response = JSON.pretty_generate(response).gsub(/\n\s*/, "")
         { raw: raw_response, parsed: JSON.parse(raw_response) }
       end
 
+      def model
+        @model ||= Lluminary::Models::Base.new
+      end
+
       private
 
       def generate_response(fields)

data/lib/lluminary/schema.rb

@@ -31,10 +31,30 @@ module Lluminary
       @fields[name] = { type: :datetime, description: description }
     end
 
+    def array(name, description: nil, &block)
+      field = { type: :array, description: description }
+
+      if block
+        element_schema = ArrayElementSchema.new
+        field[:element_type] = element_schema.instance_eval(&block)
+      end
+
+      @fields[name] = field
+    end
+
     attr_reader :fields
 
     def validates(*args, **options)
       @validations << [args, options]
+      # Attach the validation to each field it applies to
+      args.each do |field_name|
+        field = @fields[field_name]
+        next unless field # Skip if field doesn't exist yet
+
+        field[:validations] ||= []
+        # Store each validation option separately
+        options.each { |key, value| field[:validations] << { key => value } }
+      end
     end
 
     def validations_for(field_name)
@@ -50,5 +70,36 @@ module Lluminary
       instance = schema_model.new(values)
       instance.valid? ? [] : instance.errors.full_messages
     end
+
+    # Internal class for defining array element types
+    class ArrayElementSchema
+      def string(description: nil)
+        { type: :string, description: description }
+      end
+
+      def integer(description: nil)
+        { type: :integer, description: description }
+      end
+
+      def boolean(description: nil)
+        { type: :boolean, description: description }
+      end
+
+      def float(description: nil)
+        { type: :float, description: description }
+      end
+
+      def datetime(description: nil)
+        { type: :datetime, description: description }
+      end
+
+      def array(description: nil, &block)
+        field = { type: :array, description: description }
+        field[:element_type] = ArrayElementSchema.new.instance_eval(
+          &block
+        ) if block
+        field
+      end
+    end
   end
 end

data/lib/lluminary/schema_model.rb

@@ -45,6 +45,58 @@ module Lluminary
 
         # Add type validations
         validate do |record|
+          def validate_array_field(
+            record,
+            name,
+            value,
+            element_type,
+            path = nil
+          )
+            field_name = path || name
+
+            unless value.is_a?(Array)
+              record.errors.add(field_name, "must be an Array")
+              return
+            end
+
+            return unless element_type # untyped array
+
+            value.each_with_index do |element, index|
+              current_path = "#{field_name}[#{index}]"
+
+              case element_type[:type]
+              when :array
+                validate_array_field(
+                  record,
+                  name,
+                  element,
+                  element_type[:element_type],
+                  current_path
+                )
+              when :string
+                unless element.is_a?(String)
+                  record.errors.add(current_path, "must be a String")
+                end
+              when :integer
+                unless element.is_a?(Integer)
+                  record.errors.add(current_path, "must be an Integer")
+                end
+              when :boolean
+                unless [true, false].include?(element)
+                  record.errors.add(current_path, "must be true or false")
+                end
+              when :float
+                unless element.is_a?(Float)
+                  record.errors.add(current_path, "must be a float")
+                end
+              when :datetime
+                unless element.is_a?(DateTime)
+                  record.errors.add(current_path, "must be a DateTime")
+                end
+              end
+            end
+          end
+
           record.attributes.each do |name, value|
             next if name == "raw_response"
             next if value.nil?
@@ -73,6 +125,8 @@ module Lluminary
               unless value.is_a?(DateTime)
                 record.errors.add(name, "must be a DateTime")
               end
+            when :array
+              validate_array_field(record, name, value, field[:element_type])
             end
           end
         end