smart_prompt 0.4.4 → 0.5.0

data/lib/smart_prompt/message.rb

@@ -0,0 +1,57 @@
+require 'time'
+
+module SmartPrompt
+  # Message represents a single message in a conversation history
+  # It contains role, content, timestamp, and metadata
+  class Message
+    attr_reader :role, :content, :timestamp, :metadata, :token_count
+    attr_accessor :importance_score, :is_summary
+
+    def initialize(data)
+      @role = data[:role] || data["role"]
+      @content = data[:content] || data["content"]
+      @timestamp = parse_timestamp(data[:timestamp] || data["timestamp"])
+      @metadata = data[:metadata] || data["metadata"] || {}
+      @token_count = nil  # Lazy calculation
+      @importance_score = data[:importance_score] || data["importance_score"]
+      @is_summary = data[:is_summary] || data["is_summary"] || false
+    end
+
+    # Calculate token count using provided counter
+    def calculate_tokens(counter)
+      @token_count ||= counter.count(@content)
+    end
+
+    # Check if this is a system message
+    def system_message?
+      @role == "system" || @role == :system
+    end
+
+    # Convert message to hash format
+    def to_h
+      {
+        role: @role,
+        content: @content,
+        timestamp: @timestamp.iso8601,
+        metadata: @metadata,
+        importance_score: @importance_score,
+        is_summary: @is_summary
+      }
+    end
+
+    private
+
+    def parse_timestamp(timestamp)
+      case timestamp
+      when Time
+        timestamp
+      when String
+        Time.parse(timestamp)
+      when nil
+        Time.now
+      else
+        Time.now
+      end
+    end
+  end
+end

data/lib/smart_prompt/multimodal_adapter.rb

@@ -0,0 +1,277 @@
+require "openai"
+require "base64"
+
+module SmartPrompt
+  class MultimodalAdapter < LLMAdapter
+    SUPPORTED_IMAGE_FORMATS = %w[jpg jpeg png gif bmp webp]
+    SUPPORTED_VIDEO_FORMATS = %w[mp4 mov avi mkv webm]
+
+    def initialize(config)
+      super
+      api_key = @config["api_key"]
+      if api_key.is_a?(String) && api_key.start_with?("ENV[") && api_key.end_with?("]")
+        api_key = eval(api_key)
+      end
+      begin
+        @client = OpenAI::Client.new(
+          access_token: api_key,
+          uri_base: @config["url"],
+          request_timeout: 240,
+        )
+      rescue OpenAI::ConfigurationError => e
+        SmartPrompt.logger.error "Failed to initialize Multimodal client: #{e.message}"
+        raise LLMAPIError, "Invalid Multimodal configuration: #{e.message}"
+      rescue OpenAI::Error => e
+        SmartPrompt.logger.error "Failed to initialize Multimodal client: #{e.message}"
+        raise LLMAPIError, "Multimodal authentication failed: #{e.message}"
+      rescue SocketError => e
+        SmartPrompt.logger.error "Failed to initialize Multimodal client: #{e.message}"
+        raise LLMAPIError, "Network error: Unable to connect to Multimodal API"
+      rescue => e
+        SmartPrompt.logger.error "Failed to initialize Multimodal client: #{e.message}"
+        raise Error, "Unexpected error initializing Multimodal client: #{e.message}"
+      ensure
+        SmartPrompt.logger.info "Successfully created a Multimodal client."
+      end
+    end
+
+    def send_request(messages, model = nil, temperature = 0.7, tools = nil, proc = nil)
+      SmartPrompt.logger.info "MultimodalAdapter: Sending multimodal request"
+
+      # Process messages to handle multimodal content
+      processed_messages = process_multimodal_messages(messages)
+
+      temperature = 0.7 if temperature.nil?
+      model_name = model || @config["model"]
+
+      SmartPrompt.logger.info "MultimodalAdapter: Using model #{model_name}"
+
+      begin
+        parameters = {
+          model: model_name,
+          messages: processed_messages,
+          temperature: @config["temperature"] || temperature,
+        }
+
+        if proc
+          parameters[:stream] = proc
+        end
+
+        if tools
+          parameters[:tools] = tools
+        end
+
+        SmartPrompt.logger.info "Send parameters is: #{parameters}"
+        response = @client.chat(parameters: parameters)
+
+      rescue OpenAI::Error => e
+        SmartPrompt.logger.error "Multimodal API error: #{e.message}"
+        raise LLMAPIError, "Multimodal API error: #{e.message}"
+      rescue OpenAI::MiddlewareErrors => e
+        SmartPrompt.logger.error "Multimodal HTTP Error: #{e.message}"
+        raise LLMAPIError, "Multimodal HTTP Error"
+      rescue JSON::ParserError => e
+        SmartPrompt.logger.error "Failed to parse Multimodal API response"
+        raise LLMAPIError, "Failed to parse Multimodal API response"
+      rescue => e
+        SmartPrompt.logger.error "Unexpected error during Multimodal request: #{e.message}"
+        raise Error, "Unexpected error during Multimodal request: #{e.message}"
+      ensure
+        SmartPrompt.logger.info "Successfully sent multimodal message"
+      end
+
+      SmartPrompt.logger.info "MultimodalAdapter: Received response from Multimodal API"
+
+      if proc.nil?
+        @last_response = response
+        return response.dig("choices", 0, "message", "content")
+      end
+    end
+
+    # Analyze image with text prompt
+    def analyze_image(image_input, prompt, model = nil, detail: "auto", max_tokens: nil)
+      SmartPrompt.logger.info "MultimodalAdapter: Analyzing image"
+
+      messages = [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image_url", image_url: prepare_image_input(image_input, detail) }
+          ]
+        }
+      ]
+
+      model_name = model || @config["model"]
+      parameters = {
+        model: model_name,
+        messages: messages,
+        temperature: @config["temperature"] || 0.7,
+      }
+
+      parameters[:max_tokens] = max_tokens if max_tokens
+
+      response = @client.chat(parameters: parameters)
+      @last_response = response
+      response.dig("choices", 0, "message", "content")
+    end
+
+    # Analyze video with text prompt
+    def analyze_video(video_input, prompt, model = nil, max_frames: 10, fps: 1, detail: "auto")
+      SmartPrompt.logger.info "MultimodalAdapter: Analyzing video"
+
+      messages = [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "video_url", video_url: prepare_video_input(video_input, max_frames, fps, detail) }
+          ]
+        }
+      ]
+
+      model_name = model || @config["model"]
+      response = @client.chat(parameters: {
+        model: model_name,
+        messages: messages,
+        temperature: @config["temperature"] || 0.7,
+      })
+
+      @last_response = response
+      response.dig("choices", 0, "message", "content")
+    end
+
+    # Multi-image analysis
+    def analyze_multiple_images(images, prompt, model = nil, detail: "auto")
+      SmartPrompt.logger.info "MultimodalAdapter: Analyzing multiple images"
+
+      content = [{ type: "text", text: prompt }]
+      images.each do |image_input|
+        content << { type: "image_url", image_url: prepare_image_input(image_input, detail) }
+      end
+
+      messages = [{ role: "user", content: content }]
+
+      model_name = model || @config["model"]
+      response = @client.chat(parameters: {
+        model: model_name,
+        messages: messages,
+        temperature: @config["temperature"] || 0.7,
+      })
+
+      @last_response = response
+      response.dig("choices", 0, "message", "content")
+    end
+
+    private
+
+    def process_multimodal_messages(messages)
+      messages.map do |message|
+        if message[:content].is_a?(Array)
+          # Process content array with multimodal elements
+          processed_content = message[:content].map do |content_item|
+            if content_item.is_a?(Hash)
+              case content_item[:type]
+              when "image_url"
+                { type: "image_url", image_url: prepare_image_input(content_item[:image_url], content_item[:detail]) }
+              when "video_url"
+                { type: "video_url", video_url: prepare_video_input(content_item[:video_url], content_item[:max_frames], content_item[:fps], content_item[:detail]) }
+              else
+                content_item
+              end
+            else
+              { type: "text", text: content_item.to_s }
+            end
+          end
+          { role: message[:role], content: processed_content }
+        else
+          message
+        end
+      end
+    end
+
+    def prepare_image_input(image_input, detail = "auto")
+      detail ||= "auto"
+
+      case image_input
+      when String
+        if image_input.start_with?("http://", "https://")
+          { url: image_input, detail: detail }
+        elsif File.exist?(image_input)
+          # Convert local file to base64
+          file_ext = File.extname(image_input).downcase.delete(".")
+          unless SUPPORTED_IMAGE_FORMATS.include?(file_ext)
+            raise Error, "Unsupported image format: #{file_ext}"
+          end
+
+          image_data = File.binread(image_input)
+          base64_data = Base64.strict_encode64(image_data)
+          mime_type = "image/#{file_ext == 'jpg' ? 'jpeg' : file_ext}"
+
+          { url: "data:#{mime_type};base64,#{base64_data}", detail: detail }
+        else
+          raise Error, "Invalid image input: #{image_input}"
+        end
+      when Hash
+        # Assume it's already formatted
+        image_input[:detail] ||= detail
+        image_input
+      else
+        raise Error, "Unsupported image input type: #{image_input.class}"
+      end
+    end
+
+    def prepare_video_input(video_input, max_frames = 10, fps = 1, detail = "auto")
+      max_frames ||= 10
+      fps ||= 1
+      detail ||= "auto"
+
+      case video_input
+      when String
+        if video_input.start_with?("http://", "https://")
+          {
+            url: video_input,
+            detail: detail,
+            max_frames: max_frames,
+            fps: fps
+          }
+        elsif File.exist?(video_input)
+          # For local files, we'd need to upload or convert
+          # Currently only support URLs for videos
+          raise Error, "Local video files not yet supported. Please provide a URL."
+        else
+          raise Error, "Invalid video input: #{video_input}"
+        end
+      when Hash
+        # Assume it's already formatted
+        video_input[:max_frames] ||= max_frames
+        video_input[:fps] ||= fps
+        video_input[:detail] ||= detail
+        video_input
+      else
+        raise Error, "Unsupported video input type: #{video_input.class}"
+      end
+    end
+
+    def embeddings(text, model)
+      SmartPrompt.logger.info "MultimodalAdapter: Getting embeddings"
+
+      model_name = model || @config["model"]
+      begin
+        response = @client.embeddings(
+          parameters: {
+            model: model_name,
+            input: text.to_s,
+          },
+        )
+      rescue => e
+        SmartPrompt.logger.error "Unexpected error during embeddings request: #{e.message}"
+        raise Error, "Unexpected error during embeddings request: #{e.message}"
+      ensure
+        SmartPrompt.logger.info "Successfully got embeddings"
+      end
+
+      response.dig("data", 0, "embedding")
+    end
+  end
+end

data/lib/smart_prompt/openai_adapter.rb

@@ -31,19 +31,7 @@ module SmartPrompt
       end
     end
 
-    REQUEST_PARAMETER_KEYS = %w[
-      max_tokens
-      max_completion_tokens
-      top_p
-      top_k
-      response_format
-      tool_choice
-      parallel_tool_calls
-      seed
-      stop
-    ].freeze
-
-    def send_request(messages, model = nil, temperature = 0.7, tools = nil, proc = nil, request_options = {})
+    def send_request(messages, model = nil, temperature = 0.7, tools = nil, proc = nil)
       SmartPrompt.logger.info "OpenAIAdapter: Sending request to OpenAI"
       temperature = 0.7 if temperature == nil
       if model
@@ -58,8 +46,6 @@ module SmartPrompt
           messages: messages,
           temperature: @config["temperature"] || temperature,
         }
-        parameters.merge!(configured_request_parameters)
-        parameters.merge!(request_options || {})
         if proc
           parameters[:stream] = proc
         end
@@ -113,15 +99,5 @@ module SmartPrompt
       end
       return response.dig("data", 0, "embedding")
     end
-
-    private
-
-    def configured_request_parameters
-      REQUEST_PARAMETER_KEYS.each_with_object({}) do |key, parameters|
-        next unless @config.key?(key)
-
-        parameters[key.to_sym] = @config[key]
-      end
-    end
   end
 end

data/lib/smart_prompt/persistence_layer.rb

@@ -0,0 +1,197 @@
+require 'json'
+require 'fileutils'
+require 'thread'
+
+module SmartPrompt
+  # AsyncWriter handles asynchronous write operations to avoid blocking
+  class AsyncWriter
+    def initialize
+      @queue = Queue.new
+      @worker_thread = nil
+      @running = false
+      @mutex = Mutex.new
+    end
+
+    # Enqueue a block to be executed asynchronously
+    def enqueue(&block)
+      ensure_worker_running
+      @queue << block
+    end
+
+    # Stop the worker thread gracefully
+    def stop
+      @mutex.synchronize do
+        @running = false
+      end
+      @queue << :stop if @worker_thread
+      @worker_thread&.join
+    end
+
+    # Check if the worker is running
+    def running?
+      @mutex.synchronize { @running }
+    end
+
+    private
+
+    def ensure_worker_running
+      @mutex.synchronize do
+        return if @running
+
+        @running = true
+        @worker_thread = Thread.new { worker_loop }
+      end
+    end
+
+    def worker_loop
+      loop do
+        task = @queue.pop
+        break if task == :stop
+
+        begin
+          task.call if task.respond_to?(:call)
+        rescue => e
+          SmartPrompt.logger.error "AsyncWriter task failed: #{e.message}\n#{e.backtrace.join("\n")}"
+        end
+      end
+    rescue => e
+      SmartPrompt.logger.error "AsyncWriter worker loop crashed: #{e.message}"
+    ensure
+      @mutex.synchronize { @running = false }
+    end
+  end
+
+  # PersistenceLayer handles saving and loading session data to/from disk
+  class PersistenceLayer
+    attr_reader :storage_path, :enabled
+
+    def initialize(config = {})
+      @backend = config[:backend] || :filesystem
+      @storage_path = config[:storage_path] || "./history_data"
+      @async_writer = AsyncWriter.new
+      @enabled = config[:enabled] != false
+      @async = config[:async] != false
+
+      # Create storage directory if persistence is enabled
+      ensure_storage_directory if @enabled
+    end
+
+    # Save a session synchronously
+    def save(session)
+      return unless @enabled
+
+      file_path = session_file_path(session.id)
+      data = serialize_session(session)
+
+      File.write(file_path, data)
+      SmartPrompt.logger.info "Session #{session.id} saved to #{file_path}"
+    rescue => e
+      SmartPrompt.logger.error "Failed to save session #{session.id}: #{e.message}"
+      # Continue operating with in-memory storage (fallback behavior)
+    end
+
+    # Save a session asynchronously
+    def save_async(session)
+      return unless @enabled
+
+      if @async
+        @async_writer.enqueue do
+          save(session)
+        end
+      else
+        # If async is disabled, fall back to synchronous save
+        save(session)
+      end
+    end
+
+    # Load a session from disk
+    def load(session_id)
+      return nil unless @enabled
+
+      file_path = session_file_path(session_id)
+      return nil unless File.exist?(file_path)
+
+      data = File.read(file_path)
+      session_data = deserialize_session(data)
+      
+      SmartPrompt.logger.info "Session #{session_id} loaded from #{file_path}"
+      session_data
+    rescue => e
+      SmartPrompt.logger.error "Failed to load session #{session_id}: #{e.message}"
+      nil
+    end
+
+    # Delete a session from disk
+    def delete(session_id)
+      return unless @enabled
+
+      file_path = session_file_path(session_id)
+      if File.exist?(file_path)
+        File.delete(file_path)
+        SmartPrompt.logger.info "Session #{session_id} deleted from disk"
+      end
+    rescue => e
+      SmartPrompt.logger.error "Failed to delete session #{session_id}: #{e.message}"
+    end
+
+    # Check if a session exists on disk
+    def exists?(session_id)
+      return false unless @enabled
+
+      file_path = session_file_path(session_id)
+      File.exist?(file_path)
+    end
+
+    # List all session IDs stored on disk
+    def list_sessions
+      return [] unless @enabled
+
+      Dir.glob(File.join(@storage_path, "*.json")).map do |file|
+        File.basename(file, ".json")
+      end
+    rescue => e
+      SmartPrompt.logger.error "Failed to list sessions: #{e.message}"
+      []
+    end
+
+    # Stop the async writer gracefully
+    def shutdown
+      @async_writer.stop if @async_writer
+    end
+
+    private
+
+    # Ensure the storage directory exists
+    def ensure_storage_directory
+      return if Dir.exist?(@storage_path)
+      
+      FileUtils.mkdir_p(@storage_path)
+      SmartPrompt.logger.info "Created storage directory: #{@storage_path}"
+    rescue => e
+      SmartPrompt.logger.error "Failed to create storage directory #{@storage_path}: #{e.message}"
+      @enabled = false
+    end
+
+    # Get the file path for a session
+    def session_file_path(session_id)
+      File.join(@storage_path, "#{session_id}.json")
+    end
+
+    # Serialize a session to JSON
+    def serialize_session(session)
+      JSON.pretty_generate({
+        id: session.id,
+        messages: session.messages.map(&:to_h),
+        metadata: session.metadata,
+        created_at: session.created_at.iso8601,
+        updated_at: session.updated_at.iso8601,
+        config: session.config
+      })
+    end
+
+    # Deserialize session data from JSON
+    def deserialize_session(data)
+      JSON.parse(data, symbolize_names: true)
+    end
+  end
+end