ruby_conversations 1.0.6 → 1.0.8

data/app/models/ruby_conversations/message_input.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module RubyConversations
+  # Represents an input value for a message prompt
+  class MessageInput
+    include ActiveModel::Model
+
+    # Define attributes
+    attr_accessor :id, :message_prompt_id, :placeholder_name, :value,
+                  :created_at, :updated_at
+
+    # Validations
+    validates :placeholder_name, presence: true
+    validate :value_not_nil
+
+    # Association-like methods
+    def message_prompt=(prompt)
+      @message_prompt = prompt
+      @message_prompt_id = prompt&.id
+    end
+
+    attr_reader :message_prompt
+
+    # Scopes
+    def self.ordered
+      all.sort_by(&:placeholder_name)
+    end
+
+    def self.all
+      @all ||= []
+    end
+
+    # Attributes method for serialization/logging
+    def attributes
+      base_attributes
+    end
+
+    # Method for API serialization
+    def attributes_for_api
+      {
+        id: id,
+        placeholder_name: placeholder_name,
+        value: value
+      }.compact
+    end
+
+    private
+
+    def value_not_nil
+      errors.add(:value, "can't be blank") if value.nil?
+    end
+
+    def base_attributes
+      {
+        'id' => id,
+        'message_prompt_id' => message_prompt_id,
+        'placeholder_name' => placeholder_name,
+        'value' => value,
+        'created_at' => created_at,
+        'updated_at' => updated_at
+      }
+    end
+  end
+
+  # Alias for compatibility with Zeitwerk
+  AIMessageInput = MessageInput
+end

data/app/models/ruby_conversations/message_prompt.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require_relative 'message_input'
+
+module RubyConversations
+  # Represents a prompt used to generate a message in a conversation
+  class MessagePrompt
+    include ActiveModel::Model
+
+    # Define attributes
+    attr_accessor :id, :message_id, :prompt_version_id, :name, :role, :content, :metadata,
+                  :created_at, :updated_at, :message_inputs, :draft, :message
+
+    # Define nested attributes writer
+    def message_inputs_attributes=(attributes)
+      @message_inputs ||= []
+      attributes.each do |attrs|
+        @message_inputs << RubyConversations::MessageInput.new(attrs)
+      end
+    end
+
+    # Initialization
+    def initialize(attributes = {})
+      @message_inputs = [] # Initialize inputs array
+      # Extract nested inputs before super
+      inputs_attributes = extract_nested_attributes!(attributes, :message_inputs)
+
+      super
+      initialize_message_inputs(inputs_attributes)
+    end
+
+    # Handle nested inputs initialization
+    def initialize_message_inputs(attributes_array)
+      (attributes_array || []).each do |attrs|
+        next if attrs.blank?
+
+        @message_inputs << RubyConversations::MessageInput.new(attrs)
+      end
+    end
+
+    # Attributes method for serialization/logging
+    def attributes
+      base_attributes.merge(message_inputs_attributes_hash)
+    end
+
+    # Method for API serialization
+    def attributes_for_api
+      {
+        id: id,
+        prompt_version_id: prompt_version_id,
+        name: name,
+        role: role,
+        content: content,
+        metadata: metadata,
+        draft: draft,
+        ai_message_inputs_attributes: message_inputs.map(&:attributes_for_api)
+      }.compact
+    end
+
+    private
+
+    def base_attributes
+      identity_attributes.merge(content_attributes).merge(timestamp_attributes)
+    end
+
+    def identity_attributes
+      {
+        'id' => id,
+        'message_id' => message_id,
+        'prompt_version_id' => prompt_version_id,
+        'message' => message
+      }
+    end
+
+    def content_attributes
+      {
+        'name' => name,
+        'role' => role,
+        'content' => content,
+        'metadata' => metadata,
+        'draft' => draft
+      }
+    end
+
+    def timestamp_attributes
+      {
+        'created_at' => created_at,
+        'updated_at' => updated_at
+      }
+    end
+
+    def message_inputs_attributes_hash
+      {
+        'message_inputs' => message_inputs.map(&:attributes)
+      }
+    end
+
+    # Helper method to extract nested attributes
+    def extract_nested_attributes!(attributes, key)
+      nested = extract_key_attributes(attributes, key)
+      nested_attributes = extract_key_attributes(attributes, "#{key}_attributes")
+      nested.concat(nested_attributes)
+    end
+
+    def extract_key_attributes(attributes, key)
+      attributes.delete(key) || attributes.delete(key.to_s) || attributes.delete(key.to_sym) || []
+    end
+  end
+end

data/app/models/ruby_conversations/prompt.rb

@@ -1,61 +1,70 @@
 # frozen_string_literal: true
 
-module RubyConversations
-  # A prompt is a message template that can be used to generate messages for an AI conversation.
-  class Prompt < ActiveRecord::Base
-    include Versionable
+require 'active_model'
 
-    # Constants
-    VALID_ROLES = %w[system user assistant].freeze
+module RubyConversations
+  # Represents a prompt template used to generate AI messages.
+  class Prompt
+    include ActiveModel::Model
 
-    # Associations
-    has_many :versions, class_name: RubyConversations.configuration.prompt_version_class
-    has_many :message_prompts, class_name: RubyConversations.configuration.message_prompt_class, dependent: :nullify
-    has_many :messages, through: :message_prompts, class_name: RubyConversations.configuration.message_class,
-                        source: :ai_message, dependent: :nullify
-    belongs_to :organization, optional: true
+    # Define attributes
+    attr_accessor :id, :name, :role, :message, :valid_placeholders, :temperature, :metadata, :created_at, :updated_at,
+                  :latest_version_id
 
-    # Validations
-    validates :name, presence: true, uniqueness: true
-    validates :temperature, numericality: { greater_than_or_equal_to: 0.0 }, allow_nil: true
-    validates :role, presence: true, inclusion: { in: VALID_ROLES }
-
-    # Scopes
-    scope :active, -> { where(active: true) }
-    scope :by_role, ->(role) { where(role: role) }
-    scope :with_versions, -> { includes(:versions) }
-    scope :ordered_by_name, -> { order(:name) }
-    scope :internal, -> { where(internal: true) }
-    scope :external, -> { where(internal: false) }
+    # Constants
+    ROLES = %w[system user assistant].freeze
 
     # Class methods
+    def self.roles
+      ROLES
+    end
+
     def self.find_by_name!(name)
-      find_by!(name: name.to_s.strip)
+      prompt_data = RubyConversations.client.fetch_prompt(name)
+      raise "Prompt not found: #{name}" unless prompt_data
+
+      new(prompt_data)
     end
 
-    def self.roles
-      VALID_ROLES
+    def self.find_by!(conditions)
+      name = conditions[:name]
+      find_by_name!(name)
     end
 
-    # Instance methods
-    def latest_version_id
-      populate_initial_version!
-      versions.last&.id
+    # Validations
+    validates :name, presence: true
+    validates :role, presence: true, inclusion: { in: ROLES }
+    validates :message, presence: true
+
+    # Initialization
+    def initialize(attributes = {})
+      super
     end
 
-    def populate_initial_version!
-      versions.create!(message:, temperature:, created_at:, updated_at:) if versions.empty?
+    # Basic attributes method
+    def attributes
+      instance_values
     end
 
-    def interpolate(inputs = {})
-      interpolated = message.dup
-      format(interpolated, **inputs)
+    # Method for API serialization
+    def attributes_for_api
+      {
+        id: id,
+        name: name,
+        role: role,
+        message: message,
+        valid_placeholders: valid_placeholders,
+        temperature: temperature,
+        metadata: metadata,
+        latest_version_id: latest_version_id
+      }.compact
     end
 
-    private
+    # Interpolate placeholders in the message
+    def interpolate(variables = {})
+      return message if message.nil? || variables.empty?
 
-    def versioned_attributes
-      %i[content role]
+      format(message, **variables)
     end
   end
 end

data/lib/ruby_conversations/aws_credential_provider.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-core'
+require_relative 'errors'
+
+module RubyConversations
+  # Manages AWS credentials with automatic refresh capability
+  class AwsCredentialProvider
+    class << self
+      def instance
+        @instance ||= new
+      end
+    end
+
+    def initialize
+      refresh_credentials!
+    end
+
+    def access_key_id
+      refresh_if_expired!
+      @credentials&.access_key_id
+    end
+
+    def secret_access_key
+      refresh_if_expired!
+      @credentials&.secret_access_key
+    end
+
+    def session_token
+      refresh_if_expired!
+      @credentials&.session_token
+    end
+
+    attr_reader :expiration
+
+    def refresh_credentials!
+      fetch_and_set_credentials
+    end
+
+    def refresh_if_expired!
+      return unless expired?
+
+      refresh_credentials!
+    end
+
+    private
+
+    def fetch_and_set_credentials
+      if use_mock_credentials?
+        set_mock_credentials
+      else
+        fetch_and_set_real_credentials
+      end
+    end
+
+    def use_mock_credentials?
+      ENV['RAILS_ENV'] != 'production'
+    end
+
+    def set_mock_credentials
+      @credentials = Aws::Credentials.new(
+        'mock_access_key_id',
+        'mock_secret_access_key',
+        'mock_session_token'
+      )
+      @expiration = Time.now + 3600 # 1 hour
+    end
+
+    def fetch_and_set_real_credentials
+      ecs_credentials = Aws::CredentialProviderChain.new.resolve
+      raise ConfigurationError, 'Could not resolve AWS credentials' if ecs_credentials.nil?
+
+      refresh_if_supported(ecs_credentials)
+      assign_credentials(ecs_credentials)
+    end
+
+    def refresh_if_supported(credentials)
+      credentials.refresh! if credentials.respond_to?(:refresh!)
+    end
+
+    def assign_credentials(ecs_credentials)
+      if ecs_credentials.respond_to?(:credentials)
+        @credentials = ecs_credentials.credentials
+        @expiration = ecs_credentials.expiration if ecs_credentials.respond_to?(:expiration)
+      else
+        @credentials = ecs_credentials
+        @expiration = nil
+      end
+    end
+
+    def expired?
+      return false if @expiration.nil?
+      return true if @credentials.nil?
+
+      # Refresh if we're within 5 minutes of expiration
+      @expiration < Time.now + 300
+    end
+  end
+end

data/lib/ruby_conversations/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'jwt'
+
+module RubyConversations
+  # HTTP client for interacting with the conversations API
+  class Client
+    PROMPT_ATTRIBUTES = %w[
+      id name message role temperature valid_placeholders created_at updated_at latest_version_id
+    ].freeze
+
+    def initialize(url:, jwt_secret:)
+      @url = url
+      @jwt_secret = jwt_secret
+      @jwt_token = nil
+      @jwt_expiration = nil
+    end
+
+    def store_conversation(conversation)
+      response = client.post('api/ai_conversations', conversation.conversation_attributes_for_storage)
+      handle_response(response)
+    end
+
+    def fetch_prompt(name)
+      response = client.get("api/prompts/#{name}")
+      data = handle_response(response)
+      map_prompt_attributes(data)
+    end
+
+    private
+
+    def map_prompt_attributes(data)
+      PROMPT_ATTRIBUTES.each_with_object({}) do |attr_name, attrs|
+        attrs[attr_name.to_sym] = data[attr_name]
+      end
+    end
+
+    def client
+      @client ||= build_client
+    end
+
+    def build_client
+      Faraday.new(url: @url) do |faraday|
+        faraday.request :json
+        faraday.response :json
+        faraday.request :authorization, 'Bearer', -> { current_jwt }
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def current_jwt
+      refresh_jwt if token_expired?
+      @jwt_token
+    end
+
+    def token_expired?
+      @jwt_token.nil? || @jwt_expiration.nil? || Time.now.to_i >= @jwt_expiration
+    end
+
+    def refresh_jwt
+      if @jwt_secret.respond_to?(:call)
+        refresh_callable_jwt
+      else
+        refresh_static_jwt
+      end
+    end
+
+    def refresh_callable_jwt
+      @jwt_token = @jwt_secret.call
+      decoded_token = JWT.decode(@jwt_token, nil, false).first
+      @jwt_expiration = decoded_token['exp']
+    end
+
+    def refresh_static_jwt
+      @jwt_expiration = Time.now.to_i + 3600 # 1 hour
+      payload = { exp: @jwt_expiration, iat: Time.now.to_i }
+      @jwt_token = JWT.encode(payload, @jwt_secret, 'HS256')
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200, 201
+        response.body
+      else
+        raise Error, "API request failed: #{response.body}"
+      end
+    end
+  end
+end

data/lib/ruby_conversations/configuration.rb

@@ -3,26 +3,16 @@
 module RubyConversations
   # Configuration options for RubyConversations
   class Configuration
-    attr_accessor :storage_mode, :api_url, :jwt_secret, :default_llm_model, :default_llm_provider,
-                  :conversation_class, :message_class, :message_input_class, :message_prompt_class,
-                  :prompt_class, :prompt_version_class
+    attr_accessor :api_url, :jwt_secret, :default_llm_model, :default_llm_provider
 
     def initialize
-      @storage_mode = :local
       @default_llm_model = 'claude-3-7-sonnet'
       @default_llm_provider = 'bedrock'
-      @conversation_class = 'AiConversation'
-      @message_class = 'AiMessage'
-      @message_input_class = 'AiMessageInput'
-      @message_prompt_class = 'AiMessagePrompt'
-      @prompt_class = 'Prompt'
-      @prompt_version_class = 'PromptVersion'
     end
 
     def validate!
-      return unless storage_mode == :remote
-      raise ConfigurationError, 'api_url is required for remote storage' unless api_url
-      raise ConfigurationError, 'jwt_secret is required for remote storage' unless jwt_secret
+      raise ConfigurationError, 'api_url is required' unless api_url
+      raise ConfigurationError, 'jwt_secret is required' unless jwt_secret
     end
   end
 end

data/lib/ruby_conversations/engine.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'strongmind/auth'
+
 module RubyConversations
   # Defines the Rails engine for RubyConversations.
   class Engine < ::Rails::Engine

data/lib/ruby_conversations/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Base error class for the gem
+  class Error < StandardError; end
+
+  # Error raised when there is a configuration issue
+  class ConfigurationError < Error; end
+end

data/lib/ruby_conversations/version.rb

@@ -3,7 +3,7 @@
 module RubyConversations
   MAJOR = 1
   MINOR = 0
-  PATCH = 6
+  PATCH = 8
 
   VERSION = "#{RubyConversations::MAJOR}.#{RubyConversations::MINOR}.#{RubyConversations::PATCH}".freeze
 end

data/lib/ruby_conversations.rb

@@ -1,21 +1,15 @@
 # frozen_string_literal: true
 
-require 'rails'
-require 'active_record'
-require 'ruby_llm'
-require 'faraday'
-require 'jwt'
 require 'zeitwerk'
+require 'ruby_conversations/version'
 require 'ruby_conversations/configuration'
+require 'ruby_conversations/errors'
+require 'ruby_conversations/client'
+require 'ruby_conversations/aws_credential_provider'
+require 'ruby_llm'
 
-loader = Zeitwerk::Loader.for_gem
-loader.ignore("#{__dir__}/generators")
-
-# Main module for the RubyConversations engine.
+# Main module for RubyConversations
 module RubyConversations
-  class Error < StandardError; end
-  class ConfigurationError < Error; end
-
   class << self
     attr_writer :configuration
 
@@ -25,33 +19,22 @@ module RubyConversations
 
     def configure
       yield(configuration)
-      configuration.validate!
     end
 
-    def storage
-      @storage ||= case configuration.storage_mode
-                   when :local
-                     build_local_storage
-                   when :remote
-                     build_remote_storage
-                   else
-                     raise ConfigurationError, "Unknown storage mode: #{configuration.storage_mode}"
-                   end
+    def client
+      @client ||= build_client
     end
 
     def reset!
-      @configuration = Configuration.new
-      @storage = nil
+      @configuration = nil
+      @client = nil
     end
 
     private
 
-    def build_local_storage
-      Storage::Local.new
-    end
-
-    def build_remote_storage
-      Storage::Remote.new(
+    def build_client
+      configuration.validate!
+      Client.new(
         url: configuration.api_url,
         jwt_secret: configuration.jwt_secret
       )
@@ -59,4 +42,7 @@ module RubyConversations
   end
 end
 
+# Set up Zeitwerk autoloading
+loader = Zeitwerk::Loader.new
+loader.push_dir("#{__dir__}/../app/models")
 loader.setup