ruby_conversations 1.0.7 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e51a404e8fe0e362f5429272e3c39fab96e281d8a7bf44e631e37e0ff6cdb689
-  data.tar.gz: 499bcaf7b5959b0a132fcbf79d06c69752fbfaf497cb0bbd5c22ce0fa3e5679b
+  metadata.gz: 5c9ac759157e0a174601a8eb345c21dc4cb6916408d757a54b2e7ffb44173b01
+  data.tar.gz: 6357e028b36fc6a1ad772f52ede341d638e393d6b03f9530b5951dfeaa8677da
 SHA512:
-  metadata.gz: d520b36e1c90509515a80cff8a47c03232bdb80bcd3138423e6ca1337c6c245050919c5abab03cd94cfcfb1aa1ce224f6ee9405e810e722760418f9ab8c14efa
-  data.tar.gz: 57924e0b318cb11b8c6f5f12e4614da011e5003912912f415e02dcea5ebb8090e0cfc0c4bef0d5575933667a6188edab1115126d87f3cdb88e486e3af0377db3
+  metadata.gz: 2a4f6e671026766297cf3cd4ad9ed0c66c7f4beac979480349447c3b257a69ce88aa8b38ebbf7e5ea1961e29341e749bfea8a4626f743908d64f1ecbd93efd07
+  data.tar.gz: 6abdb98f3d9df53efb8c12e894c6648417b964733f4a3ac0a0a9d28609a2faf146f7ac30f1aacb2ce71b32bdb85afecce8c46dbed67821fffa76ea2236f4a58a

data/README.md

@@ -1,10 +1,9 @@
 # RubyConversations
 
-A Rails engine for managing AI conversations with support for both local and remote storage modes. Built on top of RubyLLM for AI interactions.
+A Rails engine for managing AI conversations and storing them in prompt studio. Built on top of RubyLLM for AI interactions.
 
 ## Features
 
-- **Flexible Storage**: Choose between local database storage or remote API storage
 - **Built-in Prompt Management**: Version-controlled prompts with placeholder validation
 - **Conversation History**: Track and manage conversation threads
 - **Input/Output Storage**: Structured storage for message inputs and responses
@@ -32,38 +31,17 @@ Or install it yourself as:
 gem install ruby_conversations
 ```
 
-After installation, run the setup generator:
-
-```bash
-rails generate ai_conversation_engine:install
-```
-
-This will:
-- Create necessary database migrations
-- Generate an initializer file
-- Set up default configurations
-
 ## Configuration
 
 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 +62,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
 
@@ -93,20 +71,6 @@ conversation = project.conversations.create!
 conversation.ask("analyze_project", inputs: { name: project.name })
 ```
 
-### Remote Storage Mode
-
-```ruby
-# Configure for remote storage
-AiConversationEngine.configure do |config|
-  config.storage_mode = :remote
-  config.api_url = "https://ai-conversation-api.example.com"
-  config.jwt_secret = ENV['JWT_SECRET']
-end
-
-# Usage remains the same
-conversation = AiConversation.create!
-conversation.ask("explain_code", inputs: { code: "def hello; end" })
-```
 
 ### Real-time Updates
 

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/{ruby_conversations/concerns → concerns/ruby_conversations}/llm_credentials.rb

@@ -12,6 +12,7 @@ module RubyConversations
     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]

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/{ruby_conversations/concerns → concerns/ruby_conversations}/message_validation.rb

@@ -10,11 +10,11 @@ module RubyConversations
     private
 
     def validate_messages
-      ai_messages.each do |message|
+      messages.each do |message|
         validate_message_level(message)
         message.ai_message_prompts.each do |prompt|
           validate_prompt_level(prompt)
-          prompt.ai_message_inputs.each do |input|
+          prompt.message_inputs.each do |input|
             validate_input_level(input)
           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