smart_prompt 0.4.4 → 0.5.0

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

@@ -1,97 +1,72 @@
 require "yaml"
 require "retriable"
 require "numo/narray"
-require "base64"
 
 module SmartPrompt
   class Conversation
     include APIHandler
-    MODEL_REQUEST_OPTION_KEYS = %w[
-      max_tokens
-      max_completion_tokens
-      top_p
-      top_k
-      response_format
-      tool_choice
-      parallel_tool_calls
-      seed
-      stop
-    ].freeze
-
     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
       @adapters = engine.adapters
       @llms = engine.llms
-      @models = engine.models
       @current_llm_name = nil
       @templates = engine.templates
       @temperature = 0.7
       @current_adapter = engine.current_adapter
       @last_response = nil
       @tools = tools
-      @request_options = {}
-      @pending_content_parts = []
-      @thinking_enabled = nil
+      @session_id = session_id
+      @use_history_manager = false
     end
 
     def use(llm_name)
-      llm_name = llm_name.to_s
-      raise ConfigurationError, "LLM #{llm_name} not configured" unless @llms.key?(llm_name)
+      raise "LLM #{llm_name} not configured" unless @llms.key?(llm_name)
       @current_llm = @llms[llm_name]
       @current_llm_name = llm_name
       self
     end
 
-    def use_model(model_name)
-      model_name = model_name.to_s
-      model_config = @models[model_name] || @models[model_name.to_sym]
-      raise ConfigurationError, "Model #{model_name} not configured" unless model_config
-
-      llm_name = model_config["use"] || model_config[:use]
-      configured_model_name = model_config["model"] || model_config[:model]
-      raise ConfigurationError, "Model #{model_name} must define use" if llm_name.nil? || llm_name.empty?
-      raise ConfigurationError, "Model #{model_name} must define model" if configured_model_name.nil? || configured_model_name.empty?
-
-      use(llm_name)
-      model(configured_model_name)
-      merge_model_request_options(model_config)
-      self
-    end
-
     def model(model_name)
       @model_name = model_name
+      if @engine.config["better_prompt_db"]
+        BetterPrompt.add_model(@current_llm_name, @model_name)
+      end
     end
 
     def temperature(temperature)
       @temperature = temperature
     end
 
-    def request_options(options = {})
-      @request_options.merge!(options || {})
-      self
-    end
-
-    def thinking(enabled = true)
-      @thinking_enabled = enabled
-      if @sys_msg
-        @sys_msg = thinking_system_message(@sys_msg)
-        refresh_system_message(@sys_msg)
-      end
-      self
-    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
@@ -102,59 +77,67 @@ module SmartPrompt
         SmartPrompt.logger.info "Use template #{template_name}"
         raise "Template #{template_name} not found" unless @templates.key?(template_name)
         content = @templates[template_name].render(params)
-        add_user_content(content, with_history)
+        add_message({ role: "user", content: content }, with_history)
+        if @engine.config["better_prompt_db"]
+          BetterPrompt.add_prompt(template_name, "user", content)
+        end
         self
       else
-        add_user_content(template_name, with_history)
+        add_message({ role: "user", content: template_name }, with_history)
+        if @engine.config["better_prompt_db"]
+          BetterPrompt.add_prompt("NULL", "user", template_name)
+        end
         self
       end
     end
 
-    def sys_msg(message, params)
-      @sys_msg = thinking_system_message(message)
-      add_message({ role: "system", content: @sys_msg }, params[:with_history])
-      self
-    end
-
-    def multimodal_prompt(parts, with_history: false)
-      add_message({ role: "user", content: normalize_content_parts(parts) }, with_history)
-      self
-    end
-
-    def image(source, token_budget: nil, **metadata)
-      @pending_content_parts << media_part("image", source, token_budget: token_budget, **metadata)
-      self
-    end
-
-    def audio(source, **metadata)
-      @pending_content_parts << media_part("audio", source, **metadata)
-      self
-    end
-
-    def video(source, fps: nil, max_seconds: nil, **metadata)
-      @pending_content_parts << media_part("video", source, fps: fps, max_seconds: max_seconds, **metadata)
+    def sys_msg(message, params = {})
+      @sys_msg = message
+      add_message({ role: "system", content: message }, params[:with_history])
+      if @engine.config["better_prompt_db"]
+        BetterPrompt.add_prompt("NULL", "system", message)
+      end
       self
     end
 
     def send_msg_once
       raise "No LLM selected" if @current_llm.nil?
-      @last_response = send_llm_request(@messages, nil)
+      @last_response = @current_llm.send_request(@messages, @model_name, @temperature)
       @messages = []
       @messages << { role: "system", content: @sys_msg }
       @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?
+        if @engine.config["better_prompt_db"]
+          if params[:with_history]
+            @last_call_id = BetterPrompt.add_model_call(@current_llm_name, @model_name, history_messages, false, @temperature, 0, 0.0, 0, @tools)
+          else
+            @last_call_id = BetterPrompt.add_model_call(@current_llm_name, @model_name, @messages, false, @temperature, 0, 0.0, 0, @tools)
+          end
+        end
         if params[:with_history]
-          @last_response = send_llm_request(history_messages, nil)
+          @last_response = @current_llm.send_request(history_messages, @model_name, @temperature, @tools, nil)
         else
-          @last_response = send_llm_request(@messages, nil)
+          @last_response = @current_llm.send_request(@messages, @model_name, @temperature, @tools, nil)
         end
         if @last_response == ""
           @last_response = @current_llm.last_response
         end
+        if @engine.config["better_prompt_db"]
+          BetterPrompt.add_response(@last_call_id, @last_response, false)
+        end
         @messages = []
         @messages << { role: "system", content: @sys_msg }
         @last_response
@@ -166,10 +149,20 @@ module SmartPrompt
     def send_msg_by_stream(params = {}, &proc)
       Retriable.retriable(RETRY_OPTIONS) do
         raise ConfigurationError, "No LLM selected" if @current_llm.nil?
+        if @engine.config["better_prompt_db"]
+          if params[:with_history]
+            @last_call_id = BetterPrompt.add_model_call(@current_llm_name, @model_name, history_messages, true, @temperature, 0, 0.0, 0, @tools)
+          else
+            @last_call_id = BetterPrompt.add_model_call(@current_llm_name, @model_name, @messages, true, @temperature, 0, 0.0, 0, @tools)
+          end
+        end
         if params[:with_history]
-          send_llm_request(history_messages, proc)
+          @current_llm.send_request(history_messages, @model_name, @temperature, @tools, proc)
         else
-          send_llm_request(@messages, proc)
+          @current_llm.send_request(@messages, @model_name, @temperature, @tools, proc)
+        end
+        if @engine.config["better_prompt_db"]
+          BetterPrompt.add_response(@last_call_id, @engine.stream_response, true)
         end
         @messages = []
         @messages << { role: "system", content: @sys_msg }
@@ -204,119 +197,16 @@ module SmartPrompt
       end
     end
 
-    private
-
-    def send_llm_request(messages, proc)
-      parameters = @current_llm.method(:send_request).parameters
-      if parameters.length >= 6
-        @current_llm.send_request(messages, @model_name, @temperature, @tools, proc, @request_options)
-      else
-        @current_llm.send_request(messages, @model_name, @temperature, @tools, proc)
-      end
-    end
-
-    def merge_model_request_options(model_config)
-      explicit_options = model_config["request_options"] || model_config[:request_options] || {}
-      @request_options.merge!(explicit_options)
-      MODEL_REQUEST_OPTION_KEYS.each do |key|
-        value = model_config[key] || model_config[key.to_sym]
-        @request_options[key.to_sym] = value unless value.nil?
-      end
-    end
-
-    def add_user_content(content, with_history)
-      if @pending_content_parts.empty?
-        add_message({ role: "user", content: content }, with_history)
-      else
-        add_message({ role: "user", content: multimodal_content(content) }, with_history)
-        @pending_content_parts = []
-      end
-    end
-
-    def multimodal_content(text)
-      parts = @pending_content_parts
-      images_and_videos = parts.select { |part| ["image_url", "image", "video_url", "video"].include?(part[:type] || part["type"]) }
-      audio_parts = parts.select { |part| ["input_audio", "audio"].include?(part[:type] || part["type"]) }
-      other_parts = parts - images_and_videos - audio_parts
-      normalize_content_parts(images_and_videos + other_parts + [{ type: "text", text: text.to_s }] + audio_parts)
-    end
-
-    def normalize_content_parts(parts)
-      parts.map do |part|
-        normalized = part.transform_keys(&:to_s)
-        normalized["text"] = normalized.delete("content") if normalized["type"] == "text" && normalized.key?("content")
-        normalized
-      end
-    end
-
-    def media_part(type, source, **metadata)
-      case type
-      when "image"
-        mime_type = detect_image_mime(source)
-        data = File.binread(source)
-        base64_data = Base64.strict_encode64(data)
-        url = "data:#{mime_type};base64,#{base64_data}"
-        part = { type: "image_url", image_url: { url: url } }
-      when "audio"
-        format = detect_audio_format(source)
-        data = File.binread(source)
-        base64_data = Base64.strict_encode64(data)
-        part = { type: "input_audio", input_audio: { data: base64_data, format: format } }
-      when "video"
-        mime_type = detect_video_mime(source)
-        data = File.binread(source)
-        base64_data = Base64.strict_encode64(data)
-        url = "data:#{mime_type};base64,#{base64_data}"
-        part = { type: "video_url", video_url: { url: url } }
-      else
-        part = { type: type }
-      end
-      metadata.each do |key, value|
-        part[key] = value unless value.nil?
-      end
-      part
+    def generate_image(prompt, params = {})
+      @current_llm.generate_image(prompt, params)
     end
 
-    def detect_image_mime(path)
-      ext = File.extname(path).downcase
-      case ext
-      when ".png"  then "image/png"
-      when ".jpg", ".jpeg" then "image/jpeg"
-      when ".gif"  then "image/gif"
-      when ".webp" then "image/webp"
-      when ".bmp"  then "image/bmp"
-      when ".svg"  then "image/svg+xml"
-      else "application/octet-stream"
-      end
-    end
-
-    def detect_audio_format(path)
-      ext = File.extname(path).downcase.delete_prefix(".")
-      %w[wav mp3 ogg flac aac m4a].include?(ext) ? ext : "wav"
-    end
-
-    def detect_video_mime(path)
-      ext = File.extname(path).downcase
-      case ext
-      when ".mp4"  then "video/mp4"
-      when ".webm" then "video/webm"
-      when ".mov"  then "video/quicktime"
-      when ".avi"  then "video/x-msvideo"
-      else "application/octet-stream"
-      end
-    end
-
-    def thinking_system_message(message)
-      message = message.to_s.sub(/\A<\|think\|>\n?/, "")
-      return message if @thinking_enabled == false
-      return message unless @thinking_enabled == true
-
-      "<|think|>\n#{message}"
+    def edit_image(prompt, params = {})
+      @current_llm.edit_image(prompt, params)
     end
 
-    def refresh_system_message(message)
-      system_message = @messages.find { |item| (item[:role] || item["role"]) == "system" }
-      system_message[:content] = message if system_message
+    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