feat(chat): expose per-turn prose bubbles so hosts stop guessing from the visual tree

A turn is split into several bubbles when tool rounds run between prose, but
OnResponseReceived hands the host the whole turn concatenated — nothing says which
part landed in which bubble. Hosts that post-process bubbles had to rediscover them
by CSS class and text matching, and that guesswork breaks exactly when a turn is
split: a shipping host re-rendered the whole response into the LAST bubble, showing
the pre-tool prose twice while the sealed bubble stayed raw.

TurnStreamingBubbles exposes the bubbles in open order. Cleared on turn start, on
ClearChat and on UI rebind, so a host never gets detached elements.

Author: NeoXider

Assets/CoreAiUnity/CHANGELOG.md

@@ -6,6 +6,16 @@ Unity host: **CoreAI.Source** build, EditMode / PlayMode tests, Editor menus, do
 
 ### Added
 
+- **`CoreAiChatPanel.TurnStreamingBubbles`** — the prose bubbles of the current turn, in the order
+      they were opened. A turn is split into several bubbles when tool rounds run between prose
+      (`SealStreamingBubbleIfAny`), but `OnResponseReceived` hands the host the whole turn
+      CONCATENATED, with nothing to say which part landed in which bubble. Hosts that post-process
+      bubbles (markdown rendering, syntax highlighting, per-bubble actions) had to rediscover them
+      from the visual tree by CSS class and text matching — guesswork that breaks exactly when a turn
+      is split. A shipping host hit that: the whole response was re-rendered into the LAST bubble, so
+      the prose before the tool call appeared twice and the sealed bubble stayed unrendered (raw
+      `**`). The list is cleared when a turn starts, when the chat is cleared, and when the UI is
+      rebound, so a host never receives detached elements.
 - **Runtime log filtering: `GameLogFilter`.** Static, thread-safe entry point that works in a player:
       `MinimumLevel`, `EnabledFeatures`, `SetFeatureEnabled(feature, enabled)`, `IsFeatureEnabled`,
       `Snapshot()`, `ResetToAuthored()`. `CoreAILifetimeScope` copies `GameLogSettingsAsset` into it

Assets/CoreAiUnity/Runtime/Source/Features/Chat/CoreAiChatPanel.cs

@@ -127,6 +127,29 @@ public class CoreAiChatPanel : MonoBehaviour
         /// </summary>
         private bool _streamingBubbleSealed;
 
+        /// <summary>
+        /// Prose bubbles opened during the current turn, in order. A turn is split into several bubbles
+        /// when tool rounds run between prose (see <see cref="_streamingBubbleSealed"/>), and only this
+        /// class knows where those boundaries are: <see cref="OnResponseReceived"/> receives the whole
+        /// turn CONCATENATED, with nothing to say which part landed in which bubble.
+        /// <para>
+        /// Without this list a host that post-processes bubbles (markdown rendering, syntax highlighting,
+        /// per-bubble actions) has to rediscover them from the visual tree by CSS class and text
+        /// matching — brittle guesswork that silently breaks exactly when a turn is split. A shipping
+        /// host hit that: the whole response was re-rendered into the LAST bubble, so the prose before
+        /// the tool call was shown twice and the sealed bubble stayed unrendered.
+        /// </para>
+        /// </summary>
+        private readonly List<Label> _turnStreamingBubbles = new();
+
+        /// <summary>
+        /// Prose bubbles of the current (or last completed) turn, in the order they were opened. A turn
+        /// split by tool rounds has more than one, and each holds only its own segment of the answer.
+        /// Valid from the first streamed chunk until the next turn starts, so it can be read from
+        /// <see cref="OnResponseReceived"/> and from work scheduled shortly after it.
+        /// </summary>
+        protected IReadOnlyList<Label> TurnStreamingBubbles => _turnStreamingBubbles;
+
         /// <summary>Tracks the in-flight tool round so ToolRoundStarted can carry the last tool name.</summary>
         private string _lastToolNameInTurn;
 
@@ -1170,6 +1193,9 @@ private void ResetUiReferences()
             _apiProfileToggle = null;
             _longRequestHint = null;
             _streamingLabel = null;
+            // WHY: those bubbles belonged to the old visual tree; keeping them would hand a host
+            // detached elements to post-process.
+            _turnStreamingBubbles.Clear();
             // WHY: pending scheduler jobs die with the old visual tree; a stuck flag would block every
             // scroll after a UI rebuild.
             _scrollToBottomScheduled = false;
@@ -2431,6 +2457,9 @@ protected virtual bool ShouldUseStreamingForRole(string roleId, bool uiConfigWan
             ResetThinkFilter();
             _streamingStartedVisible = false;
             _streamingBubbleSealed = false;
+            // WHY: bubbles of the PREVIOUS turn must not leak into this one — a host reading
+            // TurnStreamingBubbles would re-render already finished bubbles with the new answer.
+            _turnStreamingBubbles.Clear();
 
             // WHY: yield so the UI thread can repaint (stop affordance) before ultra-fast stubs finish
             // the enumerator.
@@ -3495,6 +3524,9 @@ private void StartStreaming()
             MakeTextSelectable(_streamingLabel);
 
             AddBubbleContent(templateRow, contentSlot, _streamingLabel);
+            // WHY: record the bubble in open order — after the turn a host needs EVERY segment, not
+            // just the last one (see TurnStreamingBubbles).
+            _turnStreamingBubbles.Add(_streamingLabel);
             MessageScroll.Add(templateRow);
             ScrollToBottom();
         }
@@ -3645,6 +3677,10 @@ public void ClearChat(bool clearChatHistory, bool clearLongTermMemory)
                     MessageScroll.Clear();
                 }
 
+                // WHY: the bubbles were just removed from the tree; a host must not be handed
+                // detached elements to post-process.
+                _turnStreamingBubbles.Clear();
+
                 string roleId = ActiveRoleId;
                 // WHY: keep the in-memory cache consistent with the now-empty scroll, otherwise switching
                 // away and back would resurrect the cleared conversation.