ruby_conversations 1.0.6 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21b50b7538b50f2523ff08c5d963333b136fcb351b707dcd1b1af05d0f0cbdae
-  data.tar.gz: b6c081796379d8422aeae1ab84e0f71334deba217565256bcf8c9fea6efed2b3
+  metadata.gz: 0e17ddcaa7e94a64865389aacc5a81be28420996569467fa5ce09df3bd89ae15
+  data.tar.gz: c58ed8d7b057648e44775625f968b735c636085b300aad2fd0f5a6d5a73466f1
 SHA512:
-  metadata.gz: 6951d8ec707ddc5fdad0d12932b48b06f59d53a4ab02f6aa52c1056e054e1ee4eb928bf936fba4527d83c764f3f4e3f5865f82b8707004dfabfa74f337e71d41
-  data.tar.gz: 7231ccb1fde48c85fc053d9e1250f2c834a91824b053e24b044405788deb79dbdca9be076edd4cd555050c7310b2db2042e49550093eacf28a83e35fd30d69bf
+  metadata.gz: df3e61d4e421e2dbf36d46000178d90ed880f2181f2734c41e64b00b92fc4008b7a5530b568d10e302daea259d3fec9c9e3106dda1e71beb7aa7ec7e95ece901
+  data.tar.gz: d908fdd54838e93af0e93fe3d00fd579f7663182c2166741f688cf5debc25d4cd98721d8db7222deaf38865d26480cd44019d84d84e397f225e0e9eba03ed778

data/README.md

@@ -49,21 +49,11 @@ Configure the engine in `config/initializers/ai_conversation_engine.rb`:
 
 ```ruby
 AiConversationEngine.configure do |config|
-  # Storage mode: :local or :remote
-  config.storage_mode = :local
-  
-  # Remote API settings (only needed for remote mode)
-  # config.api_url = ENV['AI_CONVERSATION_API_URL']
-  # config.jwt_secret = ENV['AI_CONVERSATION_JWT_SECRET']
-  
+  # API settings
+  config.api_url = ENV['AI_CONVERSATION_API_URL']
+  config.jwt_secret = ENV['AI_CONVERSATION_JWT_SECRET']
   # Default LLM settings
   config.default_llm_model = 'gpt-4'
-  
-  # Customize model behaviors
-  config.conversation_class = 'AiConversation'
-  config.message_class = 'AiMessage'
-  config.prompt_class = 'Prompt'
-  
 end
 ```
 
@@ -84,7 +74,7 @@ conversation.ask("explain_code", inputs: { code: "def hello; end" })
 ```ruby
 # Create a conversation linked to another object
 class Project < ApplicationRecord
-  has_many :conversations, as: :conversationable, 
+  has_many :conversations, as: :conversationable,
            class_name: 'AiConversationEngine::AiConversation'
 end
 
@@ -97,8 +87,7 @@ conversation.ask("analyze_project", inputs: { name: project.name })
 
 ```ruby
 # Configure for remote storage
-AiConversationEngine.configure do |config|
-  config.storage_mode = :remote
+ConversationEngine.configure do |config|
   config.api_url = "https://ai-conversation-api.example.com"
   config.jwt_secret = ENV['JWT_SECRET']
 end

data/app/models/concerns/ruby_conversations/conversation_chat.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Handles chat-related functionality for Conversation
+  module ConversationChat
+    extend ActiveSupport::Concern
+
+    def execute(system_message: nil)
+      message = messages.last
+      raise ArgumentError, 'Conversation must have at least one message to execute' unless message
+
+      chat = setup_llm_chat(system_message: system_message)
+      response = chat.ask(message.request)
+      update_last_message_response(message, response)
+      json_response = save_conversation
+      {
+        response: response,
+        conversation: json_response
+      }
+    end
+
+    def llm
+      case model_identifier
+      when 'claude-3-7-sonnet'
+        'us.anthropic.claude-3-7-sonnet-20250219-v1:0'
+      else
+        model_identifier
+      end
+    end
+
+    private
+
+    def setup_llm_chat(system_message: nil)
+      configure_llm_credentials
+      build_chat(system_message)
+    end
+
+    def update_last_message_response(message, response)
+      message.response = response.to_h.to_json
+    end
+
+    def build_chat(system_message)
+      chat = RubyLLM.chat(model: llm, provider: provider).with_temperature(0.0)
+      chat.with_tool(tool) if tool.present?
+      chat.add_message(role: :system, content: system_message) if system_message.present?
+      chat
+    end
+  end
+end

data/app/models/concerns/ruby_conversations/conversation_messages.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Handles message-related functionality for Conversation
+  module ConversationMessages
+    extend ActiveSupport::Concern
+
+    def ask_multiple(prompt_inputs, description: nil)
+      MessageBuilder.new(self).build_from_multiple_prompts(prompt_inputs, description: description)
+      self
+    end
+
+    def ask(name, description: nil, inputs: {})
+      MessageBuilder.new(self).build_from_single_prompt(name, description: description, inputs: inputs)
+      self
+    end
+  end
+end

data/app/models/concerns/ruby_conversations/llm_credentials.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Handles the management of LLM credentials for AI conversations.
+  # This concern provides methods for configuring LLM credentials from either
+  # environment variables or an AWS credential provider.
+  module LlmCredentials
+    extend ActiveSupport::Concern
+
+    private
+
+    def configure_llm_credentials
+      RubyLLM.configure do |config|
+        credentials = ENV['AWS_ACCESS_KEY_ID'].present? ? env_credentials : provider_credentials
+        config.bedrock_region = ENV.fetch('AWS_REGION', 'us-west-2')
+        config.bedrock_api_key = credentials[:api_key]
+        config.bedrock_secret_key = credentials[:secret_key]
+        config.bedrock_session_token = credentials[:session_token]
+      end
+    end
+
+    def env_credentials
+      {
+        api_key: ENV.fetch('AWS_ACCESS_KEY_ID', nil),
+        secret_key: ENV.fetch('AWS_SECRET_ACCESS_KEY', nil),
+        session_token: ENV.fetch('AWS_SESSION_TOKEN', nil)
+      }
+    end
+
+    def provider_credentials
+      credential_provider = AwsCredentialProvider.instance
+      credential_provider.refresh_if_expired!
+      {
+        api_key: credential_provider.access_key_id,
+        secret_key: credential_provider.secret_access_key,
+        session_token: credential_provider.session_token
+      }
+    end
+  end
+end

data/app/models/concerns/ruby_conversations/message_api_attributes.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Handles API-related attribute functionality for Message
+  module MessageApiAttributes
+    extend ActiveSupport::Concern
+
+    def message_attributes_for_api
+      {
+        request: request,
+        response: response,
+        model_identifier: model_identifier,
+        change_description: change_description,
+        llm: llm
+      }.compact
+    end
+
+    def message_base_attributes
+      {
+        'request' => request,
+        'response' => response,
+        'model_identifier' => model_identifier,
+        'change_description' => change_description
+      }
+    end
+
+    def remote_attributes
+      base_attributes.compact
+    end
+
+    private
+
+    def base_attributes
+      MessageAttributes::ATTRIBUTE_NAMES.each_with_object({}) do |attr_name, attrs|
+        attrs[attr_name] = public_send(attr_name)
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_conversations/message_attributes.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Handles attribute-related functionality for Message
+  module MessageAttributes
+    extend ActiveSupport::Concern
+
+    ATTRIBUTE_NAMES = %w[
+      id ai_conversation_id request response model_identifier
+      tool change_description llm created_at updated_at
+    ].freeze
+
+    included do
+      # Define core message attributes
+      attr_accessor :request, :response, :model_identifier, :change_description
+
+      # Define relationship attributes
+      attr_accessor :ai_conversation, :message_prompts, :prompts
+
+      # Common validations
+      validates :llm, presence: true
+      validates :request, presence: true
+
+      # Override initialize to ensure arrays are initialized
+      def initialize(attributes = {})
+        @message_prompts = []
+        @prompts = []
+        super
+      end
+    end
+
+    def remote_attributes
+      base_attributes.compact
+    end
+
+    private
+
+    def base_attributes
+      ATTRIBUTE_NAMES.each_with_object({}) do |attr_name, attrs|
+        attrs[attr_name] = public_send(attr_name)
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_conversations/message_processing.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Handles message processing and initialization logic
+  module MessageProcessing
+    extend ActiveSupport::Concern
+
+    private
+
+    def process_message_prompts(msg_data)
+      prompts_data = extract_prompts_data(msg_data)
+      prompts_data.map { |prompt_data| build_message_prompt(prompt_data) }
+    end
+
+    def extract_prompts_data(msg_data)
+      prompts_data = msg_data.delete(:prompts) ||
+                     msg_data.delete(:message_prompts) ||
+                     msg_data.delete('message_prompts') ||
+                     msg_data.delete(:ai_message_prompts_attributes) ||
+                     msg_data.delete('ai_message_prompts_attributes')
+      prompts_data || []
+    end
+
+    def build_message_prompt(prompt_data)
+      inputs_data = extract_inputs_data(prompt_data)
+      processed_inputs = inputs_data.map { |input_data| build_message_input(input_data) }
+
+      prompt_instance = RubyConversations::MessagePrompt.new(
+        prompt_data.except('id', 'message_id', 'created_at', 'updated_at')
+      )
+      prompt_instance.message_inputs = processed_inputs
+      prompt_instance
+    end
+
+    def extract_inputs_data(prompt_data)
+      inputs_data = prompt_data.delete(:inputs) ||
+                    prompt_data.delete(:message_inputs) ||
+                    prompt_data.delete('message_inputs')
+      inputs_data || []
+    end
+
+    def build_message_input(input_data)
+      RubyConversations::MessageInput.new(
+        input_data.except('id', 'message_prompt_id', 'created_at', 'updated_at')
+      )
+    end
+  end
+end

data/app/models/concerns/ruby_conversations/message_validation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Provides validation methods for AI conversation messages, prompts, and inputs.
+  # This concern handles the validation of the message hierarchy in AI conversations,
+  # ensuring that all messages, their prompts, and inputs are valid.
+  module MessageValidation
+    extend ActiveSupport::Concern
+
+    private
+
+    def validate_messages
+      messages.each do |message|
+        validate_message_level(message)
+        message.ai_message_prompts.each do |prompt|
+          validate_prompt_level(prompt)
+          prompt.message_inputs.each do |input|
+            validate_input_level(input)
+          end
+        end
+      end
+    end
+
+    def validate_message_level(message)
+      return if message.valid?
+
+      message.errors.full_messages.each do |msg|
+        errors.add(:base, "Message error: #{msg}")
+      end
+    end
+
+    def validate_prompt_level(prompt)
+      return if prompt.valid?
+
+      prompt.errors.full_messages.each do |msg|
+        errors.add(:base, "Message prompt error: #{msg}")
+      end
+    end
+
+    def validate_input_level(input)
+      return if input.valid?
+
+      input.errors.full_messages.each do |msg|
+        errors.add(:base, "Message prompt input error: #{msg}")
+      end
+    end
+  end
+end

data/app/models/concerns/ruby_conversations/storable.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RubyConversations
+  # Module for handling storage functionality in Ruby Conversations
+  # Provides methods for storing and retrieving conversation data
+  module Storable
+    extend ActiveSupport::Concern
+
+    def save_conversation
+      RubyConversations.client.store_conversation(self)
+    end
+  end
+end

data/app/models/ruby_conversations/conversation.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require_relative '../concerns/ruby_conversations/conversation_chat'
+require_relative '../concerns/ruby_conversations/conversation_messages'
+require_relative '../concerns/ruby_conversations/llm_credentials'
+require_relative '../concerns/ruby_conversations/message_validation'
+require_relative '../concerns/ruby_conversations/message_processing'
+require_relative '../concerns/ruby_conversations/storable'
+module RubyConversations
+  # Represents a conversation thread, managing messages and interactions with the LLM.
+  class Conversation
+    include ActiveModel::Model
+    include ConversationChat
+    include ConversationMessages
+    include LlmCredentials
+    include MessageValidation
+    include MessageProcessing
+    include Storable
+
+    # Define attributes needed for API interaction & local state
+    attr_accessor :id, :conversationable_type, :conversationable_id, :conversationable,
+                  :messages, :tool, :created_at, :updated_at
+
+    # Validations
+    validates :messages, presence: { message: 'At least one message is required' }, on: :update
+    validate :validate_messages
+
+    # Initialization
+    def initialize(attributes = nil)
+      attributes ||= {}
+      # Ensure messages is always an array before super assigns other attributes
+      @messages = []
+      # Extract nested attributes before super tries to assign them
+      messages_attrs = attributes.delete(:messages) || attributes.delete('messages') ||
+                       attributes.delete(:messages_attributes) || attributes.delete('messages_attributes') || []
+
+      super # Initialize with remaining attributes using ActiveModel::Model
+      initialize_messages(messages_attrs)
+    end
+
+    def model_identifier
+      @model_identifier ||= RubyConversations.configuration.default_llm_model
+    end
+
+    def provider
+      @provider ||= RubyConversations.configuration.default_llm_provider
+    end
+
+    def initialize_messages(message_attributes)
+      (message_attributes || []).each do |msg_data|
+        processed_prompts = process_message_prompts(msg_data)
+
+        message_instance = RubyConversations::Message.new(msg_data.except('id', 'conversation_id', 'created_at',
+                                                                          'updated_at'))
+        message_instance.message_prompts = processed_prompts
+        @messages << message_instance # Add to the messages array
+      end
+    end
+
+    def conversation_attributes_for_storage
+      { ai_conversation: base_attributes.merge(relationship_attributes).merge(messages_attributes).compact }
+    end
+
+    private
+
+    def base_attributes
+      {
+        id: id
+      }
+    end
+
+    def configuration_attributes
+      {
+        tool: tool
+      }
+    end
+
+    def relationship_attributes
+      {
+        conversationable_type: conversationable_type,
+        conversationable_id: conversationable_id
+      }
+    end
+
+    def messages_attributes
+      {
+        messages_attributes: messages.map(&:attributes_for_api)
+      }
+    end
+
+    def validate_messages
+      messages.each do |message|
+        next if message.valid?
+
+        message.errors.full_messages.each do |msg|
+          errors.add(:messages, "invalid: #{msg}")
+        end
+      end
+    end
+  end
+end

data/app/models/ruby_conversations/message.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'active_model'
+require_relative 'message_prompt'
+require_relative '../concerns/ruby_conversations/message_attributes'
+require_relative '../concerns/ruby_conversations/message_api_attributes'
+
+module RubyConversations
+  # Represents a message in a conversation, either from the user or AI
+  class Message
+    include ActiveModel::Model
+    include MessageAttributes
+    include MessageApiAttributes
+
+    # Define attributes
+    attr_accessor :id, :conversation_id, :llm,
+                  :temperature, :tool, :metadata, :created_at, :updated_at,
+                  :message_prompts
+
+    # Constants
+    ROLES = {
+      user: 'user',
+      assistant: 'assistant'
+    }.freeze
+
+    def initialize(attributes = {})
+      @message_prompts = []
+      prompts_attributes = extract_nested_attributes!(attributes, :message_prompts)
+      # Also check for Rails-style nested attributes
+      prompts_attributes ||= extract_nested_attributes!(attributes, :ai_message_prompts_attributes)
+
+      super
+      initialize_message_prompts(prompts_attributes)
+    end
+
+    def initialize_message_prompts(attributes_array)
+      (attributes_array || []).each do |attrs|
+        next if attrs.blank?
+
+        @message_prompts << RubyConversations::MessagePrompt.new(attrs)
+      end
+    end
+
+    def message_prompts_attributes=(attributes_array)
+      @message_prompts = []
+      initialize_message_prompts(attributes_array)
+    end
+
+    # Alias for Rails nested attributes convention
+    alias ai_message_prompts_attributes= message_prompts_attributes=
+
+    # Attributes method for serialization/logging
+    def attributes
+      base_attributes.merge(
+        'llm' => llm,
+        'temperature' => temperature,
+        'tool' => tool,
+        'ai_message_prompts_attributes' => message_prompts.map(&:attributes)
+      )
+    end
+
+    # Method for API serialization
+    def attributes_for_api
+      {
+        id: id,
+        conversation_id: conversation_id,
+        metadata: metadata,
+        llm: llm,
+        tool: tool,
+        ai_message_prompts_attributes: message_prompts.map(&:attributes_for_api)
+      }.merge(message_attributes_for_api).compact
+    end
+
+    # Helper methods for role checking
+    def user?
+      request.present? && response.blank?
+    end
+
+    def assistant?
+      response.present?
+    end
+
+    def prompt_inputs
+      message_prompts.flat_map(&:message_inputs)
+    end
+
+    private
+
+    def base_attributes
+      {
+        'id' => id,
+        'conversation_id' => conversation_id,
+        'metadata' => metadata,
+        'created_at' => created_at,
+        'updated_at' => updated_at
+      }.merge(message_base_attributes)
+    end
+
+    def extract_nested_attributes!(attributes, key)
+      nested = attributes.delete(key)
+      nested ||= attributes.delete(key.to_s)
+      nested
+    end
+  end
+
+  # Alias for compatibility with Zeitwerk
+  AIMessage = Message
+end

data/app/models/ruby_conversations/message_builder.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
 module RubyConversations
-  # Builds AiMessage objects with their prompts and inputs based on Prompt templates.
+  # Builds Message objects with their prompts and inputs based on Prompt templates.
   class MessageBuilder
     def initialize(conversation)
       @conversation = conversation
     end
 
     def build_from_single_prompt(name, description: nil, inputs: {})
-      prompt = Prompt.find_by!(name: name)
+      prompt = Prompt.find_by_name!(name)
       validate_inputs!(prompt, inputs)
 
       interpolated_message = prompt.interpolate(inputs)
-      message = build_ai_message(interpolated_message, description)
+      message = build_message(interpolated_message, description)
       build_prompt_association(message, prompt, inputs)
 
       message # Return the built message
     end
 
     def build_from_multiple_prompts(prompt_inputs, description: nil)
-      message = build_ai_message('', description)
+      message = build_message('', description)
 
       prompt_inputs.each do |prompt_name, inputs|
         process_single_prompt_input(message, prompt_name, inputs)
@@ -36,10 +36,7 @@ module RubyConversations
       interpolated_message = prompt.interpolate(inputs)
       message.request += "#{interpolated_message}\n\n"
 
-      message_prompt = message.ai_message_prompts.build(
-        prompt_version_id: prompt.latest_version_id,
-        draft: prompt.message
-      )
+      message_prompt = build_message_prompt(message, prompt)
       build_inputs_for_prompt(message_prompt, inputs)
     end
 
@@ -56,36 +53,64 @@ module RubyConversations
     end
 
     def build_prompt_association(message, prompt, inputs)
-      message_prompt = message.ai_message_prompts.build(
-        prompt_version_id: prompt.latest_version_id,
-        draft: prompt.message
-      )
+      message_prompt = build_message_prompt(message, prompt)
       build_inputs_for_prompt(message_prompt, inputs)
     end
 
+    def build_message_prompt(message, prompt)
+      prompt_attrs = base_prompt_attrs(prompt)
+      prompt_attrs[:message] = message
+      prompt_attrs[:name] = prompt.name
+      prompt_attrs[:role] = prompt.role
+      prompt = RubyConversations::MessagePrompt.new(prompt_attrs)
+      message.message_prompts << prompt
+      prompt
+    end
+
     def build_inputs_for_prompt(message_prompt, inputs)
       inputs.each do |input_name, value|
-        message_prompt.ai_message_inputs.build(
-          placeholder_name: input_name.to_s,
-          value: value.to_s
-        )
+        input_attrs = base_input_attrs(input_name, value)
+        input_attrs[:message_prompt] = message_prompt
+        input = RubyConversations::MessageInput.new(input_attrs)
+        message_prompt.message_inputs << input
       end
     end
 
-    # Calculates missing inputs compared to prompt placeholders
     def calculate_missing_inputs(prompt, inputs)
       required_placeholders = prompt.valid_placeholders.split(',').map(&:strip)
       provided_keys = inputs.keys.map(&:to_s)
       required_placeholders - provided_keys
     end
 
-    def build_ai_message(request, description)
-      @conversation.ai_messages.build(
+    def build_message(request, description)
+      message_attrs = base_message_attrs(request, description)
+      message = RubyConversations::Message.new(message_attrs)
+      @conversation.messages << message
+      message
+    end
+
+    def base_prompt_attrs(prompt)
+      {
+        prompt_version_id: prompt.latest_version_id,
+        draft: prompt.message
+      }
+    end
+
+    def base_message_attrs(request, description)
+      {
         request: request,
         change_description: description,
+        model_identifier: @conversation.model_identifier,
         llm: @conversation.llm,
         tool: @conversation.tool
-      )
+      }
+    end
+
+    def base_input_attrs(input_name, value)
+      {
+        placeholder_name: input_name.to_s,
+        value: value.to_s
+      }
     end
   end
 end