smart_prompt 0.4.4 → 0.5.1

data/lib/smart_prompt/compression_engine.rb

@@ -0,0 +1,201 @@
+module SmartPrompt
+  # CompressionEngine handles automatic compression of conversation history
+  # through summarization using an LLM adapter
+  # 
+  # This engine:
+  # - Generates summaries of older messages to reduce token usage
+  # - Preserves key facts, decisions, and context in summaries
+  # - Falls back to truncation strategies when summarization fails
+  # - Tracks compression metrics for monitoring
+  class CompressionEngine
+    attr_reader :config
+
+    # Initialize the compression engine
+    # @param config [Hash] Configuration options
+    # @option config [LLMAdapter] :llm_adapter LLM adapter for generating summaries
+    # @option config [String] :prompt Custom summarization prompt template
+    # @option config [Float] :compression_ratio (0.5) Target compression ratio
+    # @option config [Integer] :min_messages_to_compress (5) Minimum messages needed for compression
+    def initialize(config = {})
+      @config = config
+      @llm_adapter = config[:llm_adapter]
+      @summarization_prompt = config[:prompt] || default_prompt
+      @compression_ratio = config[:compression_ratio] || 0.5
+      @min_messages_to_compress = config[:min_messages_to_compress] || 5
+      @token_counter = TokenCounter.new
+    end
+
+    # Summarize a collection of messages into a single summary message
+    # @param messages [Array<Message>] Messages to summarize
+    # @return [Message, nil] Summary message or nil if summarization fails
+    def summarize(messages)
+      return nil if messages.nil? || messages.empty?
+      return nil if messages.length < @min_messages_to_compress
+
+      # Build the content to summarize
+      content = messages.map { |msg| "#{msg.role}: #{msg.content}" }.join("\n")
+      
+      # Create the summarization prompt
+      prompt = @summarization_prompt.gsub("{content}", content)
+
+      begin
+        # Call LLM to generate summary
+        summary_text = if @llm_adapter
+          @llm_adapter.send_request([
+            { role: "user", content: prompt }
+          ])
+        else
+          # If no LLM adapter, create a simple summary
+          create_fallback_summary(messages)
+        end
+
+        # Calculate original token count
+        original_tokens = messages.sum { |msg| msg.token_count || @token_counter.count(msg.content) }
+
+        # Create summary message
+        summary_message = Message.new(
+          role: "system",
+          content: "[Summary of previous conversation]\n#{summary_text}",
+          is_summary: true,
+          metadata: {
+            original_count: messages.count,
+            original_tokens: original_tokens,
+            compressed_at: Time.now.iso8601
+          }
+        )
+
+        # Calculate tokens for the summary
+        summary_message.calculate_tokens(@token_counter)
+
+        SmartPrompt.logger.info "Compressed #{messages.count} messages (#{original_tokens} tokens) " \
+                                "into summary (#{summary_message.token_count} tokens)"
+
+        summary_message
+      rescue => e
+        SmartPrompt.logger.error "Summarization failed: #{e.message}\n#{e.backtrace.join("\n")}"
+        nil
+      end
+    end
+
+    # Compress a session by identifying and summarizing compressible segments
+    # @param session [Session] The session to compress
+    # @return [Boolean] true if compression was successful
+    def compress(session)
+      return false if session.nil? || session.messages.empty?
+
+      begin
+        # Identify compressible message segments
+        compressible_segments = identify_compressible_segments(session.messages)
+
+        return false if compressible_segments.empty?
+
+        # Generate summaries for each segment
+        summaries = compressible_segments.map { |segment| summarize(segment) }.compact
+
+        return false if summaries.empty?
+
+        # Replace original messages with summaries
+        replace_with_summaries(session, compressible_segments, summaries)
+
+        SmartPrompt.logger.info "Session #{session.id} compressed: #{compressible_segments.flatten.count} " \
+                                "messages replaced with #{summaries.count} summaries"
+        true
+      rescue => e
+        SmartPrompt.logger.error "Compression failed for session #{session.id}: #{e.message}"
+        
+        # Fall back to truncation strategy
+        fallback_truncate(session)
+        false
+      end
+    end
+
+    # Check if a session should be compressed based on configuration
+    # @param session [Session] The session to evaluate
+    # @return [Boolean] true if compression is recommended
+    def should_compress?(session)
+      return false if session.nil?
+      
+      # Check if session has enough messages to warrant compression
+      session.message_count > (@min_messages_to_compress * 2)
+    end
+
+    private
+
+    # Default summarization prompt template
+    def default_prompt
+      "Please provide a concise summary of the following conversation, " \
+      "preserving key facts, decisions, and context. Focus on the most important " \
+      "information that would be needed to continue the conversation:\n\n{content}"
+    end
+
+    # Create a simple fallback summary when LLM is not available
+    # @param messages [Array<Message>] Messages to summarize
+    # @return [String] Simple summary text
+    def create_fallback_summary(messages)
+      "Previous conversation contained #{messages.count} messages covering various topics."
+    end
+
+    # Identify segments of messages that can be compressed
+    # Strategy: Keep recent messages, compress older ones
+    # @param messages [Array<Message>] All messages in the session
+    # @return [Array<Array<Message>>] Array of message segments to compress
+    def identify_compressible_segments(messages)
+      return [] if messages.length <= @min_messages_to_compress
+
+      # Keep the most recent 5 messages uncompressed
+      keep_recent = 5
+      
+      # Separate system messages (never compress) from others
+      system_messages = messages.select(&:system_message?)
+      non_system_messages = messages.reject(&:system_message?)
+
+      # If we don't have enough non-system messages, don't compress
+      return [] if non_system_messages.length <= keep_recent
+
+      # Identify the older messages that can be compressed
+      compressible = non_system_messages[0...-keep_recent]
+
+      # Group into segments (for now, treat all compressible messages as one segment)
+      compressible.empty? ? [] : [compressible]
+    end
+
+    # Replace original messages with summary messages in the session
+    # @param session [Session] The session to modify
+    # @param segments [Array<Array<Message>>] Original message segments
+    # @param summaries [Array<Message>] Summary messages
+    def replace_with_summaries(session, segments, summaries)
+      # Get all messages to compress (flatten segments)
+      messages_to_remove = segments.flatten
+
+      # Remove the original messages
+      session.messages.reject! { |msg| messages_to_remove.include?(msg) }
+
+      # Insert summaries at the beginning (after system messages)
+      system_messages = session.messages.select(&:system_message?)
+      other_messages = session.messages.reject(&:system_message?)
+
+      # Rebuild messages array: system messages + summaries + remaining messages
+      session.instance_variable_set(:@messages, system_messages + summaries + other_messages)
+      session.instance_variable_set(:@updated_at, Time.now)
+    end
+
+    # Fallback truncation strategy when summarization fails
+    # Simply removes oldest non-system messages to reduce size
+    # @param session [Session] The session to truncate
+    def fallback_truncate(session)
+      SmartPrompt.logger.warn "Falling back to truncation for session #{session.id}"
+
+      # Keep system messages and recent messages
+      system_messages = session.messages.select(&:system_message?)
+      non_system_messages = session.messages.reject(&:system_message?)
+
+      # Keep only the most recent half of non-system messages
+      keep_count = (non_system_messages.length * 0.5).ceil
+      kept_messages = non_system_messages.last(keep_count)
+
+      # Update session messages
+      session.instance_variable_set(:@messages, system_messages + kept_messages)
+      session.instance_variable_set(:@updated_at, Time.now)
+    end
+  end
+end

data/lib/smart_prompt/context_strategy.rb

@@ -0,0 +1,22 @@
+module SmartPrompt
+  # ContextStrategy defines the interface for context selection strategies
+  # Different strategies implement different algorithms for selecting which
+  # messages to include in the context window based on various criteria
+  module ContextStrategy
+    # Select messages from the session to include in context
+    # @param messages [Array<Message>] All messages in the session
+    # @param max_tokens [Integer, nil] Maximum token limit for selected messages
+    # @param current_message [Message, nil] The current message being processed (for relevance)
+    # @return [Array<Message>] Selected messages that fit within constraints
+    def select_messages(messages, max_tokens, current_message = nil)
+      raise NotImplementedError, "#{self.class} must implement #select_messages"
+    end
+
+    # Determine if the session should be compressed
+    # @param session [Session] The session to evaluate
+    # @return [Boolean] true if compression is recommended
+    def should_compress?(session)
+      raise NotImplementedError, "#{self.class} must implement #should_compress?"
+    end
+  end
+end

data/lib/smart_prompt/conversation.rb

@@ -20,8 +20,9 @@ module SmartPrompt
 
     attr_reader :messages, :last_response, :config_file
     attr_reader :last_call_id
+    attr_reader :session_id
 
-    def initialize(engine, tools = nil)
+    def initialize(engine, tools = nil, session_id = nil)
       SmartPrompt.logger.info "Create Conversation"
       @messages = []
       @engine = engine
@@ -37,6 +38,8 @@ module SmartPrompt
       @request_options = {}
       @pending_content_parts = []
       @thinking_enabled = nil
+      @session_id = session_id
+      @use_history_manager = false
     end
 
     def use(llm_name)
@@ -86,12 +89,29 @@ module SmartPrompt
     end
 
     def history_messages
-      @engine.history_messages
+      # If using HistoryManager, get messages from session
+      if @use_history_manager && @engine.history_manager
+        session_messages = @engine.history_manager.get_context(@session_id)
+        # Convert Message objects to hash format for backward compatibility
+        session_messages.map(&:to_h)
+      else
+        # Fall back to old implementation
+        @engine.history_messages
+      end
     end
 
     def add_message(msg, with_history = false)
       if with_history
-        history_messages << msg
+        # If HistoryManager is available, use it
+        if @engine.history_manager
+          @use_history_manager = true
+          # Ensure we have a session ID
+          @session_id ||= generate_default_session_id
+          @engine.history_manager.add_message(@session_id, msg)
+        else
+          # Fall back to old implementation
+          @engine.history_messages << msg
+        end
       end
       @messages << msg
     end
@@ -110,7 +130,7 @@ module SmartPrompt
       end
     end
 
-    def sys_msg(message, params)
+    def sys_msg(message, params = {})
       @sys_msg = thinking_system_message(message)
       add_message({ role: "system", content: @sys_msg }, params[:with_history])
       self
@@ -144,6 +164,15 @@ module SmartPrompt
       @last_response
     end
 
+    private
+
+    def generate_default_session_id
+      # Generate a default session ID based on worker name or timestamp
+      "default_#{Time.now.to_i}_#{rand(1000)}"
+    end
+
+    public
+
     def send_msg(params = {})
       Retriable.retriable(RETRY_OPTIONS) do
         raise ConfigurationError, "No LLM selected" if @current_llm.nil?
@@ -318,5 +347,19 @@ module SmartPrompt
       system_message = @messages.find { |item| (item[:role] || item["role"]) == "system" }
       system_message[:content] = message if system_message
     end
+
+    public
+
+    def generate_image(prompt, params = {})
+      @current_llm.generate_image(prompt, params)
+    end
+
+    def edit_image(prompt, params = {})
+      @current_llm.edit_image(prompt, params)
+    end
+
+    def save_image(image_data, output_dir = "./output", filename_prefix = "generated_image")
+      @current_llm.save_image(image_data, output_dir, filename_prefix)
+    end
   end
 end

data/lib/smart_prompt/engine.rb

@@ -1,7 +1,7 @@
 module SmartPrompt
   class Engine
     attr_reader :config_file, :config, :adapters, :current_adapter, :llms, :models, :templates
-    attr_reader :stream_response
+    attr_reader :stream_response, :history_manager
 
     def initialize(config_file)
       @config_file = config_file
@@ -11,6 +11,7 @@ module SmartPrompt
       @templates = {}
       @current_workers = {}
       @history_messages = []
+      @history_manager = nil
       load_config(config_file)
       SmartPrompt.logger.info "Started create the SmartPrompt engine."
       @stream_proc = Proc.new do |chunk, _bytesize|
@@ -79,6 +80,14 @@ module SmartPrompt
           template_name = file.gsub(@config["template_path"] + "/", "").gsub("\.erb", "")
           @templates[template_name] = PromptTemplate.new(file)
         end
+
+        # Initialize HistoryManager if configured
+        if @config["history"]
+          history_config = symbolize_keys(@config["history"])
+          @history_manager = HistoryManager.new(history_config)
+          SmartPrompt.logger.info "HistoryManager initialized with configuration"
+        end
+
         load_workers
       rescue Psych::SyntaxError => ex
         SmartPrompt.logger.error "YAML syntax error in config file: #{ex.message}"
@@ -146,7 +155,8 @@ module SmartPrompt
       begin
         @origin_proc = proc
         @stream_response = {}
-        worker.execute_by_stream(params, &@stream_proc)
+        ret = worker.execute_by_stream(params, &@stream_proc)
+        @stream_response = ret if @stream_response.empty?
         SmartPrompt.logger.info "Worker #{worker_name} executed(stream) successfully"
         SmartPrompt.logger.info "Worker #{worker_name} stream response is: #{@stream_response}"
       rescue => e
@@ -166,10 +176,16 @@ module SmartPrompt
     end
 
     def history_messages
+      if @history_manager
+        SmartPrompt.logger.warn "[DEPRECATED] Engine#history_messages is deprecated. Use history_manager.get_context(session_id) instead."
+      end
       @history_messages
     end
 
     def clear_history_messages
+      if @history_manager
+        SmartPrompt.logger.warn "[DEPRECATED] Engine#clear_history_messages is deprecated. Use history_manager.clear_session(session_id) instead."
+      end
       @history_messages = []
     end
 
@@ -189,5 +205,16 @@ module SmartPrompt
     def sanitize_history_content(content)
       content.to_s.gsub(/<\|channel\>thought\n.*?<channel\|>/m, "")
     end
+
+    # Recursively convert hash keys from strings to symbols
+    def symbolize_keys(hash)
+      return hash unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) do |(key, value), result|
+        new_key = key.is_a?(String) ? key.to_sym : key
+        new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
+        result[new_key] = new_value
+      end
+    end
   end
 end