smart_prompt 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b52596217dded1ca7b39d43e098de3b01f9db8e0a6acb06201399ef6c6877d
-  data.tar.gz: f29cb242e7900d1c1321451f05b5aa1075155653c6b894707ed7b172893d6833
+  metadata.gz: a2082e6227f4e29a5e1459abf8e490e557c193dcea6ec58574463f070568684e
+  data.tar.gz: f375959c75e4f67564be1d1824d7046886d54b09ea7aeb5818394d2c748f8721
 SHA512:
-  metadata.gz: ba8c550d079e37c5b5155393522568bef857821cb1440d810517f37d1067b9b7276ef46e52a5ef9e0605e066e65b53a6dc100c4a42a71585d9d99d0354322160
-  data.tar.gz: 4a2cb608d7b3aeb757a813e75ef5710ad4d106811e743d91e3dbdbb9c07f44c6d184e334eb1528a8999b551b32bbf2c4ab6037bfaabb405055fd4ab053ca4eec
+  metadata.gz: 20348a9065c3ff0ad2f3e8b790adfc88f598f09c996309b222e19a803157b140f952108f2c7e3bd7faab45bf4f719896734c156ba51c5966be435fd587792f94
+  data.tar.gz: ccd492a7abe0cccb8565bc8f39fd2ae7b950c43305e78b06a3feb9ebf7643afa6a789f6fbddd511fd499839d405d520f2da1787effdb2a6e69f3b378684908c1

data/CHANGELOG.md

@@ -12,6 +12,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 - **Refactored the Zhipu / SenseNova / SiliconFlow adapters** — extracted byte-identical cross-provider logic into four shared concerns under `lib/smart_prompt/concerns/` (`HTTPClient`, `MultimodalMessages`, `OpenAIChatShaping`, `ImagePersistence`), and split the Zhipu and SiliconFlow adapters into per-modality capability modules under `lib/smart_prompt/adapters/<provider>/` (`Text` / `Embed` / `Image` / `Video` / `Voice` / `Rerank`). Pure internal refactor — no public-API change (`send_request` stays 5-arg, all DSL-delegated method names preserved), behavior unchanged. ~286 lines removed and the previously triplicated HTTP / multimodal / chat-shaping / image-persistence code now has a single source.
 
+## [0.5.4] - 2026-09-13
+### Added
+- `Engine#system_message_transformer` hook — an optional callable applied to every system message in `Conversation#sys_msg`, so embedding applications can inject system-prompt policy (e.g. a native tool-call protocol) without monkey-patching `WorkerContext`
+- `WorkerContext#transient_prompt` — adds a user prompt to the current request only, without persisting it to `HistoryManager`
+- `HistoryManager#upsert_system_message` — keeps exactly one durable system message per session (idempotent no-op when unchanged)
+
+### Fixed
+- `Message` serialization now preserves `tool_calls` / `tool_call_id` / `reasoning_content`, so HistoryManager round-trips no longer produce malformed tool requests (missing tool-call pairing) or drop DeepSeek-style reasoning content
+- `Session` trimming now operates in "pair groups", keeping an `assistant(tool_calls)` message together with the consecutive `tool` results that follow it — preventing orphan `tool` messages that the OpenAI-compatible API rejects with HTTP 400
+- `WorkerContext#sys_msg` now forwards `with_history` to `Conversation#sys_msg` (previously system messages never reached history); the durable copy is upserted rather than appended, so worker loops never accumulate one system message per round
+- `WorkerContext#send_msg` with `with_history: true` now includes `transient_prompt` messages in the request (previously they were silently dropped); the persisted-prompt pattern still sends history directly, so nothing is duplicated
+
 ## [0.5.1] - 2026-06-21
 ### Added
 - **SenseNova (商汤日日新) support** — unified `SenseNovaAdapter` covering chat (商量), multimodal vision, Cupido embeddings, and 秒画 text-to-image, with SSE streaming and reasoning-field handling

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/version.rb

@@ -1,3 +1,3 @@
 module SmartPrompt
-  VERSION = "0.5.3"
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_prompt
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - zhuang biaowei
@@ -259,7 +259,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A smart prompt management and LLM interaction gem
 test_files: []