Address comments.

Author: ethanyhou

com.microsoft.copilot.eclipse.ui/src/com/microsoft/copilot/eclipse/ui/chat/ThinkingBlock.java

@@ -27,7 +27,7 @@
 import com.microsoft.copilot.eclipse.ui.utils.UiUtils;
 
 /**
- * Collapsible "Thinking" banner shown above an assistant turn while the model emits thinking deltas.
+ * Collapsible "Thinking" banner shown above an assistant turn while the model emits thinking stream.
  *
  * <p>Pure view: callers drive the visual state via {@link #showCompleted(String)} and {@link #showCancelled()}.
  * The owning turn widget is responsible for cancellation events and title fetching.
@@ -48,6 +48,14 @@ class ThinkingBlock extends Composite {
   private final StringBuilder textBuffer = new StringBuilder();
   private boolean expanded = true;
 
+  /**
+   * Lifecycle of the block. Transitions are always forward: STREAMING → (SEALED →)? → COMPLETED|CANCELLED.
+   * SEALED means {@code sealThinking()} has fired and a title fetch is in flight; new thinking stream fragments must
+   * start a new block.
+   */
+  private enum State { STREAMING, SEALED, COMPLETED, CANCELLED }
+
+  private State state = State.STREAMING;
   private SpinnerAnimator spinner;
   private Image cancelledIcon;
   private Image downArrowImage;
@@ -76,7 +84,7 @@ public ThinkingBlock(Composite parent, int style) {
     updateChevron();
   }
 
-  /** Append a thinking delta. Null/empty fragments are ignored. */
+  /** Append a thinking stream fragment. Null/empty fragments are ignored. */
   public void appendText(String fragment) {
     if (fragment == null || fragment.isEmpty()) {
       return;
@@ -100,6 +108,7 @@ public void showCompleted(String title) {
     }
     setTitleText(title);
     setExpanded(false);
+    state = State.COMPLETED;
   }
 
   /** Swap to the cancel icon, set the cancelled title, and collapse. No-op if already finalized. */
@@ -117,11 +126,27 @@ public void showCancelled() {
     }
     setTitleText(Messages.thinking_cancelledTitle);
     setExpanded(false);
+    state = State.CANCELLED;
   }
 
-  /** True once the spinner has stopped (block has been completed or cancelled). */
+  /**
+   * Mark the block as sealed: the owning widget has requested a title and any further thinking stream fragments must
+   * land in a new block. No-op once the block has been finalized or already sealed.
+   */
+  public void markSealed() {
+    if (state == State.STREAMING) {
+      state = State.SEALED;
+    }
+  }
+
+  /** True only while new thinking stream fragments should still be appended to this block. */
+  public boolean isAcceptingThinkStream() {
+    return state == State.STREAMING;
+  }
+
+  /** True once the block has been completed or cancelled (spinner stopped, final title shown). */
   public boolean isFinalized() {
-    return spinner == null;
+    return state == State.COMPLETED || state == State.CANCELLED;
   }
 
   /** The full accumulated thinking text streamed so far. */
@@ -191,8 +216,13 @@ public void mouseUp(MouseEvent e) {
         toggleExpanded();
       }
     };
+    // Attach to every header child (and the header itself) so the entire area that shows the hand
+    // cursor is actually clickable. iconLabel is intentionally excluded: it hosts the live spinner
+    // animation (and the cancel icon afterwards), and a clickable spinner is an odd affordance.
+    header.addMouseListener(toggleListener);
     titleText.addMouseListener(toggleListener);
     chevronLabel.addMouseListener(toggleListener);
+    filler.addMouseListener(toggleListener);
   }
 
   private void createBody() {
@@ -256,8 +286,10 @@ private static List<ParsedSection> parseSections(String raw) {
     String currentTitle = null;
     int cursor = 0;
     while (matcher.find()) {
-      String body = raw.substring(cursor, matcher.start()).strip();
-      if (currentTitle != null || !body.isEmpty()) {
+      // Preserve the body's original whitespace (e.g. leading indentation for code blocks); only strip the
+      // trailing newline(s) that visually separate the body from the upcoming title delimiter.
+      String body = stripTrailingNewlines(raw.substring(cursor, matcher.start()));
+      if (currentTitle != null || !body.isBlank()) {
         result.add(new ParsedSection(currentTitle, body));
       }
       currentTitle = matcher.group(1).trim();
@@ -267,13 +299,22 @@ private static List<ParsedSection> parseSections(String raw) {
         cursor++;
       }
     }
-    String tail = raw.substring(cursor).strip();
-    if (currentTitle != null || !tail.isEmpty()) {
+    // Tail has no following title delimiter; only trim trailing newlines so leading indentation survives.
+    String tail = stripTrailingNewlines(raw.substring(cursor));
+    if (currentTitle != null || !tail.isBlank()) {
       result.add(new ParsedSection(currentTitle, tail));
     }
     return result;
   }
 
+  private static String stripTrailingNewlines(String s) {
+    int end = s.length();
+    while (end > 0 && s.charAt(end - 1) == '\n') {
+      end--;
+    }
+    return s.substring(0, end);
+  }
+
   private void setTitleText(String text) {
     if (titleViewer == null || titleViewer.getTextWidget().isDisposed()) {
       return;

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

@@ -8,6 +8,7 @@
 import org.eclipse.swt.widgets.Composite;
 
 import com.microsoft.copilot.eclipse.core.CopilotCore;
+import com.microsoft.copilot.eclipse.core.lsp.CopilotLanguageServerConnection;
 import com.microsoft.copilot.eclipse.core.lsp.protocol.GenerateThinkingTitleParams;
 import com.microsoft.copilot.eclipse.core.lsp.protocol.Thinking;
 import com.microsoft.copilot.eclipse.ui.chat.services.ChatServiceManager;
@@ -19,8 +20,6 @@
 public abstract class ThinkingTurnWidget extends BaseTurnWidget {
 
   private ThinkingBlock currentBlock;
-  /** True once {@link #sealThinking()} has fired for {@link #currentBlock}; the next delta will start a new block. */
-  private boolean sealed;
 
   /** Construct a turn widget that supports streaming thinking blocks. */
   protected ThinkingTurnWidget(Composite parent, int style, ChatServiceManager serviceManager, String turnId,
@@ -34,7 +33,7 @@ public ThinkingTurnWidget getActiveTurnWidget() {
   }
 
   /**
-   * Append a thinking delta from the language server, routing to the active turn (parent or subagent).
+   * Append a thinking stream fragment from the language server, routing to the active turn (parent or subagent).
    * Must be called on the UI thread.
    */
   public void appendThinking(Thinking thinking) {
@@ -48,9 +47,11 @@ public void appendThinking(Thinking thinking) {
     if (active == null || active.isDisposed()) {
       return;
     }
-    if (active.currentBlock == null || active.currentBlock.isDisposed() || active.sealed) {
+    // Single source of truth: ThinkingBlock decides whether it can accept more thinking stream fragments (it can't
+    // once sealed, completed, or cancelled). Any of those transitions must start a fresh block.
+    if (active.currentBlock == null || active.currentBlock.isDisposed()
+        || !active.currentBlock.isAcceptingThinkStream()) {
       active.currentBlock = new ThinkingBlock(active, SWT.NONE);
-      active.sealed = false;
     }
     active.currentBlock.appendText(thinking.text());
   }
@@ -68,23 +69,30 @@ public void sealThinking() {
       return;
     }
     ThinkingBlock target = active.currentBlock;
-    // Skip when already sealed, or when a prior cancel has already finalized the block (so we don't fire a stale
-    // generateTitle request whose response would be discarded).
-    if (target == null || target.isDisposed() || active.sealed || target.isFinalized()) {
+    // Skip when the block is no longer accepting thinking stream fragments (already sealed, completed, or cancelled)
+    // so we don't fire a stale generateTitle request whose response would be discarded.
+    if (target == null || target.isDisposed() || !target.isAcceptingThinkStream()) {
       return;
     }
     String content = target.getAccumulatedText();
     if (StringUtils.isBlank(content)) {
-      // Nothing to title; leave the block alone (still in-progress) so a later delta can keep streaming.
+      // Nothing to title; leave the block alone (still in-progress) so a later thinking stream fragment can keep
+      // streaming.
       return;
     }
-    active.sealed = true;
+    CopilotLanguageServerConnection ls = CopilotCore.getPlugin().getCopilotLanguageServer();
+    if (ls == null) {
+      target.showCancelled();
+      requestLayout();
+      return;
+    }
+    target.markSealed();
     String[] titles = target.getExtractedTitles();
     // Server schema rejects null entries inside extractedTitles, so we send one of the two fields, never both.
     boolean hasTitles = titles.length > 0;
     GenerateThinkingTitleParams params = new GenerateThinkingTitleParams(hasTitles ? null : content,
         hasTitles ? titles : null);
-    CopilotCore.getPlugin().getCopilotLanguageServer().generateThinkingTitle(params)
+    ls.generateThinkingTitle(params)
         .thenAccept(resp -> SwtUtils.invokeOnDisplayThread(() -> {
           if (target.isDisposed() || target.isFinalized()) {
             return;