smart_prompt 0.5.2 → 0.5.4

data/lib/smart_prompt/concerns/multimodal_messages.rb

@@ -0,0 +1,108 @@
+require "base64"
+require "net/http"
+require "uri"
+
+module SmartPrompt
+  # Shared multimodal-message normalization for Net::HTTP adapters (ZhipuAI, SenseNova,
+  # SiliconFlow). Turns an OpenAI-style content array into the shape the provider expects,
+  # inlining local image/audio/video files as base64 data URLs and passing http(s)/data
+  # URLs through. Each adapter previously carried a near-identical copy of this logic.
+  #
+  # SiliconFlow's variant is the superset (image_url + video_url + audio_url, preserving
+  # detail/max_frames/fps); Zhipu/SenseNova only ever send image_url, which is a subset.
+  module MultimodalMessages
+    SUPPORTED_IMAGE_FORMATS = %w[jpg jpeg png gif bmp webp].freeze
+
+    def process_multimodal_messages(messages)
+      messages.map do |msg|
+        role = msg[:role] || msg["role"]
+        content = msg[:content] || msg["content"]
+        content = content.map { |item| normalize_content_item(item) } if content.is_a?(Array)
+        { "role" => role, "content" => content }
+      end
+    end
+
+    def normalize_content_item(item)
+      return { "type" => "text", "text" => item.to_s } unless item.is_a?(Hash)
+
+      case item[:type] || item["type"]
+      when "image_url"
+        normalize_media_part(item, "image_url", :image)
+      when "video_url"
+        normalize_media_part(item, "video_url", :video)
+      when "audio_url"
+        normalize_media_part(item, "audio_url", :audio)
+      else
+        stringify_hash(item)
+      end
+    end
+
+    # Build an image_url/video_url/audio_url part, inlining local files as data URLs and
+    # preserving any extra keys (detail, max_frames, fps) on the media hash.
+    def normalize_media_part(item, type, media_kind)
+      iu = item[type.to_sym] || item[type]
+      if iu.is_a?(Hash)
+        url = iu[:url] || iu["url"]
+        part = { "type" => type, type => { "url" => normalize_media_url(url, media_kind) } }
+        iu.each { |k, v| part[type][k.to_s] = stringify_hash(v) unless k.to_s == "url" }
+        part
+      else
+        { "type" => type, type => { "url" => normalize_media_url(iu, media_kind) } }
+      end
+    end
+
+    # Resolve a media URL embedded in a message: http(s)/data pass through; a local path
+    # is base64-encoded as a data URL.
+    def normalize_media_url(url, kind = :image)
+      return url if url.nil?
+      return url if url.start_with?("http://", "https://", "data:")
+
+      label = kind == :image ? "Image" : kind.to_s.capitalize
+      raise Error, "#{label} file not found: #{url}" unless File.exist?(url)
+      ext = File.extname(url).downcase.delete(".")
+      case kind
+      when :image
+        raise Error, "Unsupported image format: #{ext}" unless SUPPORTED_IMAGE_FORMATS.include?(ext)
+        mime = ext == "jpg" ? "jpeg" : ext
+        "data:image/#{mime};base64,#{Base64.strict_encode64(File.binread(url))}"
+      when :audio
+        "data:audio/#{ext.empty? ? 'wav' : ext};base64,#{Base64.strict_encode64(File.binread(url))}"
+      when :video
+        "data:video/#{ext.empty? ? 'mp4' : ext};base64,#{Base64.strict_encode64(File.binread(url))}"
+      end
+    end
+
+    # Single-arg image-only shim (call sites like generate_video pass a plain image URL).
+    def normalize_image_url(url)
+      normalize_media_url(url, :image)
+    end
+
+    # Accept a local path, a base64 data URL, or an http(s) URL for image-edit /
+    # image-to-video `image` fields.
+    def normalize_input_image(image)
+      return image if image.nil?
+
+      if image.is_a?(String)
+        return image if image.start_with?("data:")
+        return image if image.start_with?("http://", "https://")
+      end
+
+      raise Error, "Image file not found: #{image}" unless File.exist?(image)
+      ext = File.extname(image).downcase.delete(".")
+      raise Error, "Unsupported image format: #{ext}" unless SUPPORTED_IMAGE_FORMATS.include?(ext)
+      mime = ext == "jpg" ? "jpeg" : ext
+      "data:image/#{mime};base64,#{Base64.strict_encode64(File.binread(image))}"
+    end
+
+    def stringify_hash(hash)
+      case hash
+      when Hash
+        hash.each_with_object({}) { |(k, v), memo| memo[k.to_s] = stringify_hash(v) }
+      when Array
+        hash.map { |v| stringify_hash(v) }
+      else
+        hash
+      end
+    end
+  end
+end

data/lib/smart_prompt/concerns/openai_chat_shaping.rb

@@ -0,0 +1,87 @@
+module SmartPrompt
+  # Shared shaping of Net::HTTP chat responses into the OpenAI completion / stream
+  # shape that the rest of SmartPrompt (Engine#@stream_proc, Conversation) expects.
+  #
+  # Reasoning models expose a thinking trace under a provider-specific field —
+  # surfaced here uniformly as `reasoning_content`. Adapters override one hook:
+  #
+  #   reasoning_field_name  — the source field on message/delta (default
+  #     "reasoning_content"; SenseNova uses "reasoning"). Its value is remapped to
+  #     reasoning_content so Engine#@stream_proc needs no per-provider logic.
+  #
+  #   extra_top_level_fields(raw) — extra top-level keys to copy onto the shaped
+  #     response/chunk (default {}; SenseNova adds system_fingerprint).
+  module OpenAIChatShaping
+    def build_completion_response(raw)
+      msg = raw.dig("choices", 0, "message") || {}
+      message = { "role" => msg["role"] || "assistant" }
+      message["content"] = msg["content"]
+      reasoning = msg[reasoning_field_name]
+      message["reasoning_content"] = reasoning if reasoning
+      message["tool_calls"] = msg["tool_calls"] if msg["tool_calls"]
+
+      response = {
+        "id"      => raw["id"],
+        "object"  => raw["object"] || "chat.completion",
+        "created" => raw["created"],
+        "model"   => raw["model"],
+        "choices" => [{
+          "index"         => 0,
+          "message"       => message,
+          "finish_reason" => raw.dig("choices", 0, "finish_reason"),
+        }],
+      }
+      response["usage"] = raw["usage"] if raw["usage"]
+      merge_extra_top_level(response, raw)
+      response
+    end
+
+    def build_stream_chunk(data)
+      chunk = {
+        "id"      => data["id"],
+        "object"  => data["object"],
+        "created" => data["created"],
+        "model"   => data["model"],
+      }
+      chunk["usage"] = data["usage"] if data["usage"]
+      merge_extra_top_level(chunk, data)
+
+      choices = data["choices"] || []
+      if choices.any?
+        delta = choices[0]["delta"] || {}
+        new_delta = {}
+        new_delta["role"]              = delta["role"]        if delta["role"]
+        new_delta["content"]           = delta["content"]     if delta["content"]
+        reasoning = delta[reasoning_field_name]
+        new_delta["reasoning_content"] = reasoning if reasoning
+        new_delta["tool_calls"]        = delta["tool_calls"]  if delta["tool_calls"]
+        chunk["choices"] = [{
+          "index"         => choices[0]["index"] || 0,
+          "delta"         => new_delta,
+          "finish_reason" => choices[0]["finish_reason"],
+        }]
+      else
+        chunk["choices"] = []
+      end
+      chunk
+    end
+
+    # ---- hooks (override in adapter) -----------------------------------------
+
+    def reasoning_field_name
+      "reasoning_content"
+    end
+
+    def extra_top_level_fields(_raw)
+      {}
+    end
+
+    private
+
+    def merge_extra_top_level(target, raw)
+      extra_top_level_fields(raw).each do |k, v|
+        target[k] = v unless v.nil? || target.key?(k)
+      end
+    end
+  end
+end

data/lib/smart_prompt/conversation.rb

@@ -131,8 +131,9 @@ module SmartPrompt
     end
 
     def sys_msg(message, params = {})
-      @sys_msg = thinking_system_message(message)
-      add_message({ role: "system", content: @sys_msg }, params[:with_history])
+      @sys_msg = thinking_system_message(transform_system_message(message))
+      upsert_system_message(@sys_msg) if params[:with_history]
+      add_message({ role: "system", content: @sys_msg }, false)
       self
     end
 
@@ -171,6 +172,29 @@ module SmartPrompt
       "default_#{Time.now.to_i}_#{rand(1000)}"
     end
 
+    # Apply an optional engine-level hook so embedding applications can inject
+    # their own system-prompt policy (e.g. a native tool-call protocol) without
+    # monkey-patching WorkerContext.
+    def transform_system_message(message)
+      transformer = @engine.system_message_transformer if @engine.respond_to?(:system_message_transformer)
+      transformer ? transformer.call(message) : message
+    end
+
+    # Keep exactly one durable system message per session. Repeated rounds
+    # replace the persisted system copy instead of appending snapshots of
+    # changing progress/repair state forever.
+    def upsert_system_message(content)
+      if @engine.history_manager
+        @use_history_manager = true
+        @session_id ||= generate_default_session_id
+        @engine.history_manager.upsert_system_message(@session_id, content)
+      else
+        messages = Array(@engine.history_messages)
+        messages.delete_if { |item| (item[:role] || item["role"]).to_s == "system" }
+        messages << { role: "system", content: content }
+      end
+    end
+
     public
 
     def send_msg(params = {})

data/lib/smart_prompt/engine.rb

@@ -2,6 +2,10 @@ module SmartPrompt
   class Engine
     attr_reader :config_file, :config, :adapters, :current_adapter, :llms, :models, :templates
     attr_reader :stream_response, :history_manager
+    # Optional callable applied to every system message in Conversation#sys_msg.
+    # Lets an embedding application inject its own system-prompt policy (e.g. a
+    # native tool-call protocol) without monkey-patching WorkerContext.
+    attr_accessor :system_message_transformer
 
     def initialize(config_file)
       @config_file = config_file
@@ -12,6 +16,7 @@ module SmartPrompt
       @current_workers = {}
       @history_messages = []
       @history_manager = nil
+      @system_message_transformer = nil
       load_config(config_file)
       SmartPrompt.logger.info "Started create the SmartPrompt engine."
       @stream_proc = Proc.new do |chunk, _bytesize|

data/lib/smart_prompt/history_manager.rb

@@ -104,6 +104,28 @@ module SmartPrompt
       end
     end
 
+    # Keep exactly one durable system message per session. Repeated worker rounds
+    # replace the persisted system copy instead of appending snapshots of
+    # changing progress/repair state forever. Returns false when the session
+    # already held an identical single system message (idempotent no-op).
+    def upsert_system_message(session_id, content, options = {})
+      begin
+        session = get_session(session_id, options)
+        systems = session.messages.select(&:system_message?)
+        if systems.one? && systems.first.content.to_s == content.to_s
+          return false
+        end
+
+        session.messages.delete_if(&:system_message?)
+      rescue => e
+        log_error "Failed to upsert system message in session #{session_id}", e
+        raise HistoryManagerError, "Failed to upsert system message: #{e.message}"
+      end
+
+      add_message(session_id, { role: "system", content: content.to_s }, options)
+      true
+    end
+
     # Get context (messages) from a session
     def get_context(session_id, max_tokens = nil, strategy = nil)
       begin

data/lib/smart_prompt/message.rb

@@ -4,7 +4,8 @@ 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_reader :role, :content, :timestamp, :metadata, :token_count,
+                :tool_calls, :tool_call_id, :reasoning_content
     attr_accessor :importance_score, :is_summary
 
     def initialize(data)
@@ -15,6 +16,12 @@ module SmartPrompt
       @token_count = nil  # Lazy calculation
       @importance_score = data[:importance_score] || data["importance_score"]
       @is_summary = data[:is_summary] || data["is_summary"] || false
+      # Tool-call pairing and reasoning fields must survive serialization so
+      # HistoryManager round-trips don't drop tool_calls / tool_call_id /
+      # reasoning_content and produce malformed tool requests.
+      @tool_calls = data[:tool_calls] || data["tool_calls"]
+      @tool_call_id = data[:tool_call_id] || data["tool_call_id"]
+      @reasoning_content = data[:reasoning_content] || data["reasoning_content"]
     end
 
     # Calculate token count using provided counter
@@ -29,7 +36,7 @@ module SmartPrompt
 
     # Convert message to hash format
     def to_h
-      {
+      h = {
         role: @role,
         content: @content,
         timestamp: @timestamp.iso8601,
@@ -37,6 +44,10 @@ module SmartPrompt
         importance_score: @importance_score,
         is_summary: @is_summary
       }
+      h[:tool_calls] = @tool_calls if @tool_calls
+      h[:tool_call_id] = @tool_call_id if @tool_call_id
+      h[:reasoning_content] = @reasoning_content if @reasoning_content
+      h
     end
 
     private

data/lib/smart_prompt/session.rb

@@ -90,20 +90,27 @@ module SmartPrompt
       end
     end
 
-    # Remove oldest non-system messages to meet message count limit
+    # Remove oldest non-system messages to meet message count limit, trimming
+    # in "pair groups" so an assistant(tool_calls) message is never separated
+    # from the tool results that follow it.
     def remove_oldest_messages_to_limit(max_messages)
       system_messages = @messages.select(&:system_message?)
       non_system_messages = @messages.reject(&:system_message?)
 
-      # Keep only the most recent non-system messages
-      messages_to_keep = max_messages - system_messages.length
-      messages_to_keep = [messages_to_keep, 0].max
+      messages_to_keep = [max_messages - system_messages.length, 0].max
 
-      kept_non_system = non_system_messages.last(messages_to_keep)
-      @messages = system_messages + kept_non_system
+      kept = []
+      count = 0
+      pair_groups(non_system_messages).reverse_each do |group|
+        break if count + group.length > messages_to_keep
+
+        kept.unshift(group)
+        count += group.length
+      end
+      @messages = system_messages + kept.flatten
     end
 
-    # Remove oldest non-system messages to meet token limit
+    # Remove oldest non-system messages to meet token limit, also in pair groups.
     def remove_oldest_messages_to_token_limit(max_tokens)
       system_messages = @messages.select(&:system_message?)
       non_system_messages = @messages.reject(&:system_message?)
@@ -111,21 +118,45 @@ module SmartPrompt
       system_tokens = system_messages.sum { |msg| msg.token_count || 0 }
       available_tokens = max_tokens - system_tokens
 
-      # Keep adding messages from the end until we hit the token limit
-      kept_messages = []
+      kept = []
       current_tokens = 0
+      pair_groups(non_system_messages).reverse_each do |group|
+        group_tokens = group.sum { |msg| msg.token_count || 0 }
+        break if current_tokens + group_tokens > available_tokens
+
+        kept.unshift(group)
+        current_tokens += group_tokens
+      end
+      @messages = system_messages + kept.flatten
+    end
 
-      non_system_messages.reverse_each do |msg|
-        msg_tokens = msg.token_count || 0
-        if current_tokens + msg_tokens <= available_tokens
-          kept_messages.unshift(msg)
-          current_tokens += msg_tokens
+    # Split non-system messages into groups where an assistant message that
+    # carries tool_calls stays together with the consecutive tool results that
+    # follow it. Every other message forms its own single-element group.
+    def pair_groups(messages)
+      groups = []
+      i = 0
+      while i < messages.length
+        msg = messages[i]
+        if assistant_with_tool_calls?(msg)
+          group = [msg]
+          i += 1
+          while i < messages.length && messages[i].role.to_s == "tool"
+            group << messages[i]
+            i += 1
+          end
+          groups << group
         else
-          break
+          groups << [msg]
+          i += 1
         end
       end
+      groups
+    end
 
-      @messages = system_messages + kept_messages
+    def assistant_with_tool_calls?(msg)
+      msg.role.to_s == "assistant" &&
+        msg.respond_to?(:tool_calls) && msg.tool_calls && !msg.tool_calls.empty?
     end
 
     # Calculate importance score for a message

data/lib/smart_prompt/siliconflow_adapter.rb

@@ -0,0 +1,91 @@
+require "base64"
+require "json"
+require "net/http"
+require "uri"
+require "fileutils"
+require_relative "concerns/image_persistence"
+require_relative "concerns/openai_chat_shaping"
+require_relative "concerns/multimodal_messages"
+require_relative "concerns/http_client"
+require_relative "adapters/siliconflow/text"
+require_relative "adapters/siliconflow/embed"
+require_relative "adapters/siliconflow/image"
+require_relative "adapters/siliconflow/video"
+require_relative "adapters/siliconflow/voice"
+require_relative "adapters/siliconflow/rerank"
+
+module SmartPrompt
+  # Adapter for 硅基流动 (SiliconFlow / SiliconCloud) — one adapter owns the whole
+  # provider: every category shares the base URL https://api.siliconflow.cn/v1 and
+  # Bearer auth.
+  #
+  # Per-modality behavior lives in capability modules under adapters/siliconflow/
+  # (Text / Embed / Image / Video / Voice / Rerank); cross-provider plumbing (HTTP,
+  # multimodal normalization, chat shaping, image saving) comes from the shared
+  # concerns. This class wires them together + holds config/credentials.
+  #
+  # Provider-specific quirks (all vs https://docs.siliconflow.cn/cn/api-reference):
+  #   chat/vision — POST {base}/chat/completions (reasoning_content, no remap)
+  #   embeddings  — POST {base}/embeddings        (dimensions only for Qwen3-Embedding)
+  #   rerank      — POST {base}/rerank            (results[].relevance_score)
+  #   image/edit  — POST {base}/images/generations (images[].url; image_size/batch_size/guidance_scale)
+  #   video       — POST {base}/video/submit -> POST {base}/video/status (async; results.videos[].url)
+  #   tts         — POST {base}/audio/speech       (binary audio response)
+  #   asr         — POST {base}/audio/transcriptions (multipart, field "file")
+  #   voice       — /uploads/audio/voice, /audio/voice/list, /audio/voice/deletions
+  class SiliconFlowAdapter < LLMAdapter
+    DEFAULT_BASE_URL = "https://api.siliconflow.cn/v1".freeze
+
+    # Cross-provider shared concerns
+    include ImagePersistence
+    include OpenAIChatShaping
+    include MultimodalMessages
+    include HTTPClient
+
+    # Per-capability modules
+    include SiliconFlow::Text
+    include SiliconFlow::Embed
+    include SiliconFlow::Image
+    include SiliconFlow::Video
+    include SiliconFlow::Voice
+    include SiliconFlow::Rerank
+
+    # ---- hooks for shared concerns -------------------------------------------
+    def provider_label
+      "SiliconFlow"
+    end
+
+    def default_image_prefix
+      "siliconflow_image"
+    end
+
+    def initialize(config)
+      super
+      SmartPrompt.logger.info "Start create the SmartPrompt SiliconFlowAdapter."
+
+      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
+      # Tolerate a missing key at construction (e.g. when the ENV var isn't set yet)
+      # and let the first request fail with a clear auth error.
+      SmartPrompt.logger.warn "SiliconFlow api_key is empty — API calls will fail until it is set." if api_key.nil? || api_key.to_s.strip.empty?
+
+      @api_key  = api_key
+      @base_url = (@config["url"] || DEFAULT_BASE_URL).to_s.chomp("/")
+      # Optional per-method URL overrides (default to the standard paths off @base_url).
+      @image_url         = (@config["image_url"]         || "#{@base_url}/images/generations").to_s
+      @video_submit_url  = (@config["video_submit_url"]  || "#{@base_url}/video/submit").to_s
+      @video_status_url  = (@config["video_status_url"]  || "#{@base_url}/video/status").to_s
+      @speech_url        = (@config["speech_url"]        || "#{@base_url}/audio/speech").to_s
+      @transcription_url = (@config["transcription_url"] || "#{@base_url}/audio/transcriptions").to_s
+      @voice_upload_url  = (@config["voice_upload_url"]  || "#{@base_url}/uploads/audio/voice").to_s
+      @voice_list_url    = (@config["voice_list_url"]    || "#{@base_url}/audio/voice/list").to_s
+      @voice_delete_url  = (@config["voice_delete_url"]  || "#{@base_url}/audio/voice/deletions").to_s
+      SmartPrompt.logger.info "SiliconFlow base_url=#{@base_url}"
+    rescue => e
+      SmartPrompt.logger.error "Failed to initialize SiliconFlow client: #{e.message}"
+      raise e.is_a?(SmartPrompt::Error) ? e : LLMAPIError, "Invalid SiliconFlow configuration: #{e.message}"
+    end
+  end
+end

data/lib/smart_prompt/version.rb

@@ -1,3 +1,3 @@
 module SmartPrompt
-  VERSION = "0.5.2"
+  VERSION = "0.5.4"
 end

data/lib/smart_prompt/worker.rb

@@ -57,18 +57,42 @@ module SmartPrompt
       @params = params
       @engine = engine
       @proc = proc
+      @transient_messages = []
+    end
+
+    # Add a user prompt to the current request only, without persisting it to
+    # HistoryManager. Progress, retry notes and hard-intervention text are
+    # snapshots, not conversation history; persisting one large user message per
+    # round would evict the assistant/tool evidence we need to retain.
+    def transient_prompt(content)
+      @transient_messages << content
+      @conversation.prompt(content, with_history: false)
     end
 
     def method_missing(method, *args, &block)
       if @conversation.respond_to?(method)
         if method == :send_msg
-          if @proc == nil
-            @conversation.send_msg(params)
+          send_params = params
+          if params[:with_history] && !@transient_messages.empty?
+            # The default send path would send *only* history_messages when
+            # with_history=true, silently dropping the transient prompt just
+            # added to @conversation.messages. Merge both sources for this
+            # request and use the ordinary send path. When there is no transient
+            # prompt, keep the original with_history send so the persisted
+            # prompt pattern is not duplicated.
+            prepare_transient_history_request!
+            send_params = params.merge(with_history: false)
+          end
+          if @proc.nil?
+            @conversation.send_msg(send_params)
           else
-            @conversation.send_msg_by_stream(params, &@proc)
+            @conversation.send_msg_by_stream(send_params, &@proc)
           end
         elsif method == :sys_msg
-          @conversation.sys_msg(*args)
+          # The system message always belongs to the current request. Its
+          # durable session copy is upserted by Conversation#sys_msg so a worker
+          # loop never accumulates one preserved system message per round.
+          @conversation.sys_msg(*args, with_history: params[:with_history])
         elsif method == :prompt
           @conversation.prompt(*args, with_history: params[:with_history])
         else
@@ -80,7 +104,7 @@ module SmartPrompt
     end
 
     def respond_to_missing?(method, include_private = false)
-      @conversation.respond_to?(method) || super
+      method == :transient_prompt || @conversation.respond_to?(method) || super
     end
 
     def params
@@ -107,5 +131,43 @@ module SmartPrompt
       worker = Worker.new(worker_name, @engine)
       worker.execute_by_stream(params, proc)
     end
+
+    private
+
+    # Merge the persisted session history with the transient prompts recorded
+    # this round. Persisted prompts stay in history_messages and are therefore
+    # already part of the request, so only the transient user messages need to
+    # be appended to avoid duplication.
+    def prepare_transient_history_request!
+      current = Array(@conversation.messages)
+      history = session_history
+      SmartPrompt.logger&.info(
+        "[SmartPrompt history] session=#{@params[:session_id]} " \
+        "messages=#{history.size} roles=#{history.map { |message| message_role(message) }.tally}"
+      )
+      system = current.select { |message| message_role(message) == "system" }
+      historical_turns = history.reject { |message| message_role(message) == "system" }
+      transient_turn = @transient_messages.map { |content| { role: "user", content: content } }
+      @conversation.instance_variable_set(:@messages, system + historical_turns + transient_turn)
+    end
+
+    def session_history
+      if @engine.respond_to?(:history_manager) && @engine.history_manager
+        sid = @params[:session_id]
+        raise ArgumentError, "history requires an explicit session_id" if sid.to_s.strip.empty?
+
+        @engine.history_manager.get_context(sid).map(&:to_h)
+      elsif @engine.respond_to?(:history_messages)
+        Array(@engine.history_messages)
+      else
+        []
+      end
+    end
+
+    def message_role(message)
+      return message.role.to_s if message.respond_to?(:role)
+
+      (message[:role] || message["role"]).to_s
+    end
   end
 end