Fix run-on paragraphs when model resumes after mid-turn tool call

Empty agent_message_chunk events mark content block boundaries in
the ACP stream (e.g. the model described a code change, then reported
background test results).  These empty chunks were appended as-is,
inserting nothing, so the two blocks merged: "pipeline.Full test suite".

Convert empty mid-stream chunks to "\n\n" paragraph breaks.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: timvisher-dd

agent-shell.el

@@ -1648,36 +1648,44 @@ COMMAND, when present, may be a shell command string or an argv vector."
                     :expanded agent-shell-thought-process-expand-by-default))))
              (map-put! state :last-entry-type "agent_thought_chunk")))
           ((equal (map-nested-elt acp-notification '(params update sessionUpdate)) "agent_message_chunk")
-           ;; Notification is out of context (session/prompt finished).
-           ;; Cannot derive where to display, so show in minibuffer.
-           (if (not (agent-shell--active-requests-p state))
-               (when acp-logging-enabled
-                 (message "Agent message (stale, consider reporting to ACP agent): %s"
-                          (truncate-string-to-width (map-nested-elt acp-notification '(params update content text)) 100)))
-             (unless (equal (map-elt state :last-entry-type) "agent_message_chunk")
-               (map-put! state :chunked-group-count (1+ (map-elt state :chunked-group-count)))
+           (let ((chunk-text (map-nested-elt acp-notification '(params update content text))))
+             ;; An empty chunk while already streaming message text
+             ;; indicates a content block boundary (the model resumed
+             ;; after a tool call within the same turn).  Convert to a
+             ;; paragraph break so the two blocks don't run together.
+             (when (and (equal (map-elt state :last-entry-type) "agent_message_chunk")
+                        (stringp chunk-text)
+                        (string-empty-p chunk-text))
+               (setq chunk-text "\n\n"))
+             ;; Notification is out of context (session/prompt finished).
+             ;; Cannot derive where to display, so show in minibuffer.
+             (if (not (agent-shell--active-requests-p state))
+                 (when acp-logging-enabled
+                   (message "Agent message (stale, consider reporting to ACP agent): %s"
+                            (truncate-string-to-width chunk-text 100)))
+               (unless (equal (map-elt state :last-entry-type) "agent_message_chunk")
+                 (map-put! state :chunked-group-count (1+ (map-elt state :chunked-group-count)))
+                 (agent-shell--append-transcript
+                  :text (format "\n## Agent (%s)\n\n" (format-time-string "%F %T"))
+                  :file-path agent-shell--transcript-file))
+               ;; Indent markdown headers in LLM output so they nest
+               ;; below the transcript's ## section headers.  Applied
+               ;; per-chunk: if a header is split across chunks it may
+               ;; not be indented (graceful degradation).
                (agent-shell--append-transcript
-                :text (format "\n## Agent (%s)\n\n" (format-time-string "%F %T"))
-                :file-path agent-shell--transcript-file))
-             ;; Indent markdown headers in LLM output so they nest
-             ;; below the transcript's ## section headers.  Applied
-             ;; per-chunk: if a header is split across chunks it may
-             ;; not be indented (graceful degradation).
-             (agent-shell--append-transcript
-              :text (agent-shell--indent-markdown-headers
-                     (map-nested-elt acp-notification '(params update content text)))
-              :file-path agent-shell--transcript-file)
-             (agent-shell--update-fragment
-              :state state
-              :block-id (format "%s-agent_message_chunk"
-                                (map-elt state :chunked-group-count))
-              :body (map-nested-elt acp-notification '(params update content text))
-              :create-new (not (equal (map-elt state :last-entry-type)
-                                      "agent_message_chunk"))
-              :append t
-              :navigation 'never
-              :render-body-images t)
-             (map-put! state :last-entry-type "agent_message_chunk")))
+                :text (agent-shell--indent-markdown-headers chunk-text)
+                :file-path agent-shell--transcript-file)
+               (agent-shell--update-fragment
+                :state state
+                :block-id (format "%s-agent_message_chunk"
+                                  (map-elt state :chunked-group-count))
+                :body chunk-text
+                :create-new (not (equal (map-elt state :last-entry-type)
+                                        "agent_message_chunk"))
+                :append t
+                :navigation 'never
+                :render-body-images t)
+               (map-put! state :last-entry-type "agent_message_chunk"))))
           ((equal (map-nested-elt acp-notification '(params update sessionUpdate)) "user_message_chunk")
            ;; Only handle user_message_chunks when there's an active session/load
            ;; or session/push to avoid inserting a redundant shell prompt

tests/agent-shell-streaming-tests.el

@@ -702,6 +702,72 @@ with no prior meta chunks.  The output must not be dropped."
       (when (buffer-live-p buffer)
         (kill-buffer buffer)))))
 
+(ert-deftest agent-shell--empty-chunk-inserts-paragraph-break-test ()
+  "An empty agent_message_chunk mid-stream inserts a paragraph break.
+Regression: when the model produces two content blocks in the same
+turn (e.g. a description followed by a background-task result),
+the ACP sends an empty chunk at the boundary.  Without converting
+that to a paragraph break, the end of the first block and the
+start of the second get merged: \"pipeline.Full test suite passed\"."
+  (let* ((buffer (get-buffer-create " *agent-shell-empty-chunk-para*"))
+         (agent-shell--state (agent-shell--make-state :buffer buffer))
+         (agent-shell--transcript-file nil)
+         (tool-id "toolu_empty_chunk_test"))
+    (map-put! agent-shell--state :client 'test-client)
+    (map-put! agent-shell--state :request-count 1)
+    (map-put! agent-shell--state :active-requests (list t))
+    (with-current-buffer buffer
+      (erase-buffer)
+      (agent-shell-mode))
+    (unwind-protect
+        (cl-letf (((symbol-function 'agent-shell--make-diff-info)
+                   (cl-function (lambda (&key acp-tool-call) (ignore acp-tool-call)))))
+          (with-current-buffer buffer
+            ;; Completed tool call (background task)
+            (agent-shell--on-notification
+             :state agent-shell--state
+             :acp-notification `((method . "session/update")
+                             (params . ((update
+                                         . ((toolCallId . ,tool-id)
+                                            (sessionUpdate . "tool_call")
+                                            (rawInput)
+                                            (status . "pending")
+                                            (title . "Bash")
+                                            (kind . "execute")))))))
+            (agent-shell--on-notification
+             :state agent-shell--state
+             :acp-notification `((method . "session/update")
+                             (params . ((update
+                                         . ((toolCallId . ,tool-id)
+                                            (sessionUpdate . "tool_call_update")
+                                            (status . "completed")))))))
+            ;; First content block: empty start chunk + text
+            (dolist (token (list "" "First paragraph" " ending."))
+              (agent-shell--on-notification
+               :state agent-shell--state
+               :acp-notification `((method . "session/update")
+                               (params . ((update
+                                           . ((sessionUpdate . "agent_message_chunk")
+                                              (content (type . "text")
+                                                       (text . ,token)))))))))
+            ;; Second content block: empty boundary chunk + text
+            (dolist (token (list "" "Second paragraph" " starting."))
+              (agent-shell--on-notification
+               :state agent-shell--state
+               :acp-notification `((method . "session/update")
+                               (params . ((update
+                                           . ((sessionUpdate . "agent_message_chunk")
+                                              (content (type . "text")
+                                                       (text . ,token)))))))))
+            ;; The two paragraphs must NOT be merged.
+            (let ((visible-text (agent-shell-test--visible-buffer-string)))
+              (should (string-match-p "First paragraph ending\\." visible-text))
+              (should (string-match-p "Second paragraph starting\\." visible-text))
+              ;; The boundary must include whitespace, not "ending.Second"
+              (should-not (string-match-p "ending\\.Second" visible-text)))))
+      (when (buffer-live-p buffer)
+        (kill-buffer buffer)))))
+
 (ert-deftest agent-shell--agent-message-chunks-fully-visible-test ()
   "All agent_message_chunk tokens must be visible in the buffer.
 Regression: label-less fragments defaulted to :collapsed t.  The