feat - Persist thinking blocks to conversation history and restore on session switch

[xinyi-gong]

resolve #201

Change 1: Persist thinking blocks to conversation history

Persist thinking block content, state, and title so thinking blocks can be restored when switching sessions or loading conversation history.

Data Model

• Add ThinkingBlockData with id, content, title, and state fields.
• Add ThinkingBlockState enum for COMPLETED and CANCELLED.
• Add thinkingBlock to EditAgentRoundData so thinking content is stored with the agent round it belongs to.
• Use a UI-generated thinking block ID as the stable identity for title/cancel updates instead of relying on server thinking IDs or round IDs.

Persistence

• Accumulate thinking stream fragments directly into a thinking block attached to an edit-agent round.
• Create a placeholder edit-agent round when thinking arrives before the corresponding AgentRound.
• When the real AgentRound arrives, merge it into the placeholder by matching the UI-generated thinking block ID.
• Update thinking titles by thinkingBlockId.
• Update cancelled thinking state by thinkingBlockId.
• Keep placeholder round IDs as a synthetic sentinel (-1) until the real server round arrives.

UI

• Generate a stable thinking block ID in ThinkingBlock.
• Add setConversationContext(conversationId, persistTurnId) to route persistence context to the active widget, including subagent widgets.
• sealThinking() uses stored context and persists generated titles by thinking block ID.
• onChatMessageCancelled() routes through getActiveTurnWidget() so subagent thinking cancellation is handled correctly.
• ChatContentViewer caches the active thinking block ID per turn while processing progress events, so ChatView can pass the correct ID to persistence without querying widget state again.
• Sync conversationId to ChatContentViewer on begin events.

Restore

• Restore thinking blocks from persisted EditAgentRoundData.thinkingBlock.
• Restore main-agent thinking blocks before their corresponding round reply/tool calls.
• Restore subagent thinking blocks inside the subagent message block.
• Preserve completed/cancelled state, generated title, and full thinking content.

Validation

• Added persistence coverage for thinking content, title updates, cancellation, and placeholder round merging.
• Added parser regression coverage for adjacent thinking section titles.
• Added manual test plans

Change 2: Fix ThinkingBlock.parseSections crash on adjacent titles

When two bold title patterns (e.g. Title1 immediately followed by Title2) appear with no body text between them, the newline-skipping logic advances the cursor past the next match's start position, causing a StringIndexOutOfBoundsException. This crashes the entire conversation restore and leaves the chat panel broken.

Fix: guard the substring call with a cursor <= matcher.start() check, producing an empty body when titles are adjacent.
Stack trace:

java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 2694
	at java.base/jdk.internal.util.Preconditions$1.apply(Preconditions.java:55)
	at java.base/jdk.internal.util.Preconditions$1.apply(Preconditions.java:52)
	at java.base/jdk.internal.util.Preconditions$4.apply(Preconditions.java:213)
	at java.base/jdk.internal.util.Preconditions$4.apply(Preconditions.java:210)
	at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:98)
	at java.base/jdk.internal.util.Preconditions.outOfBoundsCheckFromToIndex(Preconditions.java:112)
	at java.base/jdk.internal.util.Preconditions.checkFromToIndex(Preconditions.java:349)
	at java.base/java.lang.String.checkBoundsBeginEnd(String.java:4849)
	at java.base/java.lang.String.substring(String.java:2823)
	at com.microsoft.copilot.eclipse.ui.chat.ThinkingBlock.parseSections(ThinkingBlock.java:351)
	at com.microsoft.copilot.eclipse.ui.chat.ThinkingBlock.refreshBody(ThinkingBlock.java:275)
	at com.microsoft.copilot.eclipse.ui.chat.ThinkingBlock.appendText(ThinkingBlock.java:101)
......

Change 3 : Fix Thinking Stream Whitespace Handling

• Preserve whitespace-only thinking stream fragments instead of filtering them with StringUtils.isBlank.
• This fixes section parsing when the language server sends a newline as its own thinking fragment before the next **Title**.
• Use StringUtils.isEmpty for thinking fragments so null / empty strings are ignored, while meaningful markdown whitespace such as "\n" is preserved.
• Persist the same whitespace-only thinking fragments so restored thinking content matches the live rendered content.

Before:

[Copilot]

Pull request overview

Persist thinking-block content/title/state into the per-conversation persistence model so they can be restored when switching sessions, and harden ThinkingBlock.parseSections against a crash that occurs when two **Title** markers appear back-to-back.

Changes:

• Add ThinkingBlockData/ThinkingBlockState and wire them into ReplyData (transient pending block) and EditAgentRoundData (attached block); add finalizeLastThinkingBlock / updateThinkingBlockTitle to ConversationPersistenceManager and accumulate thinking text in ConversationDataFactory.
• Route conversation/turn IDs from ChatView → ChatContentViewer → ThinkingTurnWidget (setConversationContext), chain finalize → title generation → title persistence in sealThinking, persist CANCELLED state in onChatMessageCancelled, and restore thinking blocks during history replay for both main and subagent turns.
• Fix ThinkingBlock.parseSections StringIndexOutOfBoundsException when adjacent titles cause cursor > matcher.start() by emitting an empty body in that case.

Reviewed changes

Copilot reviewed 8 out of 8 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
.../core/persistence/CopilotTurnData.java	Adds ThinkingBlockData/ThinkingBlockState, transient pendingThinkingBlock on ReplyData, and thinkingBlock on EditAgentRoundData.
.../core/persistence/ConversationDataFactory.java	Accumulates streamed thinking text into the reply's pending block.
.../core/persistence/ConversationPersistenceManager.java	Adds cache-only finalizeLastThinkingBlock and updateThinkingBlockTitle operations.
.../ui/chat/ThinkingTurnWidget.java	Adds setConversationContext, persistence chaining in sealThinking, cancellation persistence, and restoreThinkingBlock.
.../ui/chat/ThinkingBlock.java	Guards parseSections substring against cursor > matcher.start() from adjacent titles.
.../ui/chat/ChatContentViewer.java	Stores conversationId and propagates context to ThinkingTurnWidget on each report event.
.../ui/chat/ChatView.java	Syncs conversationId to viewer on begin; restores persisted thinking blocks per round on history replay.
.../ui/chat/BaseTurnWidget.java	Restores thinking blocks in subagent rounds; renames a local to disambiguate from the new subagentWidget.

Comments suppressed due to low confidence (2)

com.microsoft.copilot.eclipse.ui/src/com/microsoft/copilot/eclipse/ui/chat/ThinkingTurnWidget.java:96

• The new early-return when active.persistTurnId == null changes the visible behavior of sealThinking: previously the block was always sealed (and, if no LSP, completed) so the spinner stopped. Now, if the conversation context has not been propagated (e.g. an end event arrives without any prior report having set the context for the currently-active widget), the thinking block silently stays in STREAMING state forever — the spinner never stops and no title is fetched. Consider sealing/completing the block visually regardless and only skipping the persistence calls when persistTurnId is null.

    if (active.persistTurnId == null) {
      return;
    }

com.microsoft.copilot.eclipse.ui/src/com/microsoft/copilot/eclipse/ui/chat/ThinkingTurnWidget.java:163

• When persistTurnId is null, this falls back to active.turnId, but the class-level Javadoc on persistTurnId explicitly states that turnId may not match the persistence key (especially for subagent turns where turnId = toolCallId + suffix). Using active.turnId as the persistence key in that case will silently look up the wrong (or no) turn in the cache and the cancellation state will never be persisted. It would be clearer to skip the persistence call entirely when persistTurnId == null, mirroring the guard added in sealThinking.

        String cancelTurnId = active.persistTurnId != null ? active.persistTurnId : active.turnId;
        active.finalizeLastThinkingBlock(ThinkingBlockState.CANCELLED, cancelTurnId);

[jdneo]

LGTM