Fix: Stream thinking tokens live instead of showing all at once

The regex required a complete <think>...</think> block to match,
so nothing appeared in the Thinking field until the closing tag
arrived. Now parse_thinking_blocks() accepts a streaming flag
that detects unclosed <think> tags and extracts partial content
for real-time display.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -58,28 +58,45 @@ def load_model():
         raise
 
 
-def parse_thinking_blocks(content: str) -> Tuple[str, str]:
+def parse_thinking_blocks(content: str, streaming: bool = False) -> Tuple[str, str]:
     """
     Parse thinking blocks from model output.
     Supports both <think> and <thinking> tags.
 
     Args:
         content: Full model response
+        streaming: If True, handle unclosed <think> tags for live display
 
     Returns:
         Tuple of (thinking_content, summary_content)
     """
-    # Match both <think> and <thinking> tags
-    pattern = r'<think(?:ing)?>(.*?)</think(?:ing)?>'
-    matches = re.findall(pattern, content, re.DOTALL)
+    closed_pattern = r'<think(?:ing)?>(.*?)</think(?:ing)?>'
+    open_pattern = r'<think(?:ing)?>([^<]*)$'
 
-    if not matches:
-        return ("", content)
+    # Extract completed thinking blocks
+    closed_matches = re.findall(closed_pattern, content, re.DOTALL)
+    # Remove completed blocks to get summary
+    remaining = re.sub(closed_pattern, '', content, flags=re.DOTALL).strip()
 
-    thinking = '\n\n'.join(match.strip() for match in matches)
-    summary = re.sub(pattern, '', content, flags=re.DOTALL).strip()
+    thinking_parts = [m.strip() for m in closed_matches if m.strip()]
 
-    return (thinking, summary)
+    if streaming:
+        # Check for unclosed <think> tag (model still generating thinking tokens)
+        open_match = re.search(open_pattern, content, re.DOTALL)
+        if open_match:
+            partial = open_match.group(1).strip()
+            if partial:
+                thinking_parts.append(partial)
+            # Nothing after the open tag counts as summary yet
+            remaining = re.sub(r'<think(?:ing)?>[^<]*$', '', remaining, flags=re.DOTALL).strip()
+
+    thinking = '\n\n'.join(thinking_parts)
+
+    if not thinking and not closed_matches:
+        # No thinking tags found at all
+        return ("", content if not content.startswith('<think') else "")
+
+    return (thinking, remaining)
 
 
 def summarize_streaming(file_obj, max_tokens: int = 2048, temperature: float = 0.6) -> Generator[Tuple[str, str], None, None]:
@@ -158,8 +175,8 @@ def summarize_streaming(file_obj, max_tokens: int = 2048, temperature: float = 0
                     converted = converter.convert(content)
                     full_response += converted
 
-                    # Parse thinking blocks and summary from accumulated response
-                    thinking_blocks, summary = parse_thinking_blocks(full_response)
+                    # Parse thinking blocks and summary (streaming=True for partial tags)
+                    thinking_blocks, summary = parse_thinking_blocks(full_response, streaming=True)
 
                     # Update thinking field (only show thinking blocks, not raw stream)
                     current_thinking = thinking_blocks if thinking_blocks else ""