massgen 0.0.3__py3-none-any.whl → 0.1.0__py3-none-any.whl

massgen/frontend/coordination_ui.py

@@ -1,28 +1,28 @@
+# -*- coding: utf-8 -*-
 """
 MassGen Coordination UI
 
-Main interface for coordinating agents with visual display and logging.
+Main interface for coordinating agents with visual display.
 """
 
-import time
 import asyncio
-from typing import Optional, List, Dict, Any, AsyncGenerator
+import time
+from typing import Any, Dict, List, Optional
+
 from .displays.base_display import BaseDisplay
-from .displays.terminal_display import TerminalDisplay
-from .displays.simple_display import SimpleDisplay
 from .displays.rich_terminal_display import RichTerminalDisplay, is_rich_available
-from .logging.realtime_logger import RealtimeLogger
+from .displays.simple_display import SimpleDisplay
+from .displays.terminal_display import TerminalDisplay
 
 
 class CoordinationUI:
-    """Main coordination interface with display and logging capabilities."""
+    """Main coordination interface with display capabilities."""
 
     def __init__(
         self,
         display: Optional[BaseDisplay] = None,
-        logger: Optional[RealtimeLogger] = None,
+        logger: Optional[Any] = None,
         display_type: str = "terminal",
-        logging_enabled: bool = True,
         enable_final_presentation: bool = False,
         **kwargs,
     ):
@@ -32,21 +32,12 @@ class CoordinationUI:
             display: Custom display instance (overrides display_type)
             logger: Custom logger instance
             display_type: Type of display ("terminal", "simple", "rich_terminal", "textual_terminal")
-            logging_enabled: Whether to enable real-time logging
             enable_final_presentation: Whether to ask winning agent to present final answer
             **kwargs: Additional configuration passed to display/logger
         """
         self.enable_final_presentation = enable_final_presentation
         self.display = display
-        # Filter kwargs for logger (only pass logger-specific params)
-        logger_kwargs = {
-            k: v for k, v in kwargs.items() if k in ["filename", "update_frequency"]
-        }
-        self.logger = (
-            logger
-            if logger is not None
-            else (RealtimeLogger(**logger_kwargs) if logging_enabled else None)
-        )
+        self.logger = logger
         self.display_type = display_type
         self.config = kwargs
 
@@ -56,6 +47,50 @@ class CoordinationUI:
 
         # Flush output configuration (matches rich_terminal_display)
         self._flush_char_delay = 0.03  # 30ms between characters
+
+        # Initialize answer buffer state
+        self._answer_buffer = ""
+        self._answer_timeout_task = None
+        self._final_answer_shown = False
+
+    def _process_reasoning_summary(self, chunk_type: str, summary_delta: str, source: str) -> str:
+        """Process reasoning summary content using display's shared logic."""
+        if self.display and hasattr(self.display, "process_reasoning_content"):
+            return self.display.process_reasoning_content(chunk_type, summary_delta, source)
+        else:
+            # Fallback logic if no display available
+            if chunk_type == "reasoning_summary":
+                summary_active_key = f"_summary_active_{source}"
+                if not getattr(self, summary_active_key, False):
+                    setattr(self, summary_active_key, True)
+                    return f"📋 [Reasoning Summary]\n{summary_delta}\n"
+                return summary_delta
+            elif chunk_type == "reasoning_summary_done":
+                summary_active_key = f"_summary_active_{source}"
+                if hasattr(self, summary_active_key):
+                    setattr(self, summary_active_key, False)
+            return summary_delta
+
+    def _process_reasoning_content(self, chunk_type: str, reasoning_delta: str, source: str) -> str:
+        """Process reasoning summary content using display's shared logic."""
+        if self.display and hasattr(self.display, "process_reasoning_content"):
+            return self.display.process_reasoning_content(chunk_type, reasoning_delta, source)
+        else:
+            # Fallback logic if no display available
+            if chunk_type == "reasoning":
+                reasoning_active_key = f"_reasoning_active_{source}"
+                if not getattr(self, reasoning_active_key, False):
+                    setattr(self, reasoning_active_key, True)
+                    return f"🧠 [Reasoning Started]\n{reasoning_delta}\n"
+                return reasoning_delta
+            elif chunk_type == "reasoning_done":
+                reasoning_active_key = f"_reasoning_active_{source}"
+                if hasattr(self, reasoning_active_key):
+                    setattr(self, reasoning_active_key, False)
+                return reasoning_delta
+
+    def __post_init__(self):
+        """Post-initialization setup."""
         self._flush_word_delay = 0.08  # 80ms after punctuation
 
         # Initialize answer buffer state
@@ -86,10 +121,8 @@ class CoordinationUI:
         if hasattr(self, "_final_answer_shown"):
             self._final_answer_shown = False
 
-    async def coordinate(
-        self, orchestrator, question: str, agent_ids: Optional[List[str]] = None
-    ) -> str:
-        """Coordinate agents with visual display and logging.
+    async def coordinate(self, orchestrator, question: str, agent_ids: Optional[List[str]] = None) -> str:
+        """Coordinate agents with visual display.
 
         Args:
             orchestrator: MassGen orchestrator instance
@@ -99,6 +132,12 @@ class CoordinationUI:
         Returns:
             Final coordinated response
         """
+        # Initialize variables that may be referenced in finally block
+        selected_agent = ""
+        vote_results = {}
+        final_result = ""
+        final_answer = ""
+
         # Reset display to ensure clean state for each coordination
         if self.display is not None:
             self.display.cleanup()
@@ -120,9 +159,7 @@ class CoordinationUI:
                 self.display = SimpleDisplay(self.agent_ids, **self.config)
             elif self.display_type == "rich_terminal":
                 if not is_rich_available():
-                    print(
-                        "⚠️  Rich library not available. Falling back to terminal display."
-                    )
+                    print("⚠️  Rich library not available. Falling back to terminal display.")
                     print("   Install with: pip install rich")
                     self.display = TerminalDisplay(self.agent_ids, **self.config)
                 else:
@@ -149,6 +186,10 @@ class CoordinationUI:
 
         self.display.initialize(question, log_filename)
 
+        # Initialize variables to avoid reference before assignment error in finally block
+        selected_agent = None
+        vote_results = {}
+
         try:
             # Process coordination stream
             full_response = ""
@@ -166,37 +207,88 @@ class CoordinationUI:
                         self.display.update_agent_status(source, status)
                     continue
 
-                # Handle builtin tool results
-                elif chunk_type == "builtin_tool_results":
-                    builtin_results = getattr(chunk, "builtin_tool_results", [])
-                    if builtin_results and source:
-                        for result in builtin_results:
-                            tool_type = result.get("tool_type", "unknown")
-                            status_result = result.get("status", "unknown")
-                            tool_msg = (
-                                f"🔧 [{tool_type.title()}] {status_result.title()}"
-                            )
-
-                            if tool_type in ["code_interpreter", "code_execution"]:
-                                code = result.get("code", "") or result.get(
-                                    "input", {}
-                                ).get("code", "")
-                                outputs = result.get("outputs")
-                                if code:
-                                    tool_msg += f" - Code: {code[:50]}{'...' if len(code) > 50 else ''}"
-                                if outputs:
-                                    tool_msg += f" - Result: {outputs}"
-                            elif tool_type == "web_search":
-                                query = result.get("query", "") or result.get(
-                                    "input", {}
-                                ).get("query", "")
-                                if query:
-                                    tool_msg += f" - Query: '{query}'"
-
-                            # Display as tool content for the specific agent
-                            await self._process_agent_content(source, tool_msg)
+                # Filter out debug chunks from display
+                elif chunk_type == "debug":
+                    # Log debug info but don't display it
+                    if self.logger:
+                        self.logger.log_chunk(source, content, chunk_type)
+                    continue
+
+                # Filter out mcp_status chunks - display via agent panel instead of console
+                elif chunk_type == "mcp_status":
+                    # Let the display handle MCP status via agent panel
+                    if source and source in self.agent_ids:
+                        self.display.update_agent_content(source, content, "tool")
+                    if self.logger:
+                        self.logger.log_chunk(source, content, chunk_type)
+                    continue
+
+                # builtin_tool_results handling removed - now handled as simple content
+
+                # Handle reasoning streams
+                elif chunk_type in [
+                    "reasoning",
+                    "reasoning_done",
+                    "reasoning_summary",
+                    "reasoning_summary_done",
+                ]:
+                    if source:
+                        reasoning_content = ""
+                        if chunk_type == "reasoning":
+                            # Stream reasoning delta as thinking content
+                            reasoning_delta = getattr(chunk, "reasoning_delta", "")
+                            if reasoning_delta:
+                                # reasoning_content = reasoning_delta
+                                reasoning_content = self._process_reasoning_content(chunk_type, reasoning_delta, source)
+                        elif chunk_type == "reasoning_done":
+                            # Complete reasoning text
+                            reasoning_text = getattr(chunk, "reasoning_text", "")
+                            if reasoning_text:
+                                reasoning_content = f"\n🧠 [Reasoning Complete]\n{reasoning_text}\n"
+                            else:
+                                reasoning_content = "\n🧠 [Reasoning Complete]\n"
+
+                            # Reset flag using helper method
+                            self._process_reasoning_content(chunk_type, reasoning_content, source)
+
+                            # Mark summary as complete - next summary can get a prefix
+                            reasoning_active_key = "_reasoning_active"
+                            if hasattr(self, reasoning_active_key):
+                                delattr(self, reasoning_active_key)
+
+                        elif chunk_type == "reasoning_summary":
+                            # Stream reasoning summary delta
+                            summary_delta = getattr(chunk, "reasoning_summary_delta", "")
+                            if summary_delta:
+                                reasoning_content = self._process_reasoning_summary(chunk_type, summary_delta, source)
+                        elif chunk_type == "reasoning_summary_done":
+                            # Complete reasoning summary
+                            summary_text = getattr(chunk, "reasoning_summary_text", "")
+                            if summary_text:
+                                reasoning_content = f"\n📋 [Reasoning Summary Complete]\n{summary_text}\n"
+
+                            # Reset flag using helper method
+                            self._process_reasoning_summary(chunk_type, "", source)
+
+                            # Mark summary as complete - next summary can get a prefix
+                            summary_active_key = f"_summary_active_{source}"
+                            if hasattr(self, summary_active_key):
+                                delattr(self, summary_active_key)
+
+                        if reasoning_content:
+                            # Display reasoning as thinking content
+                            self.display.update_agent_content(source, reasoning_content, "thinking")
+                            if self.logger:
+                                self.logger.log_agent_content(source, reasoning_content, "reasoning")
                     continue
 
+                # Reset reasoning prefix state when final presentation starts
+                if chunk_type == "status" and "presenting final answer" in content:
+                    # Clear all summary active flags for final presentation
+                    for attr_name in list(vars(self).keys()):
+                        if attr_name.startswith("_summary_active_"):
+                            delattr(self, attr_name)
+
                 if content:
                     full_response += content
 
@@ -212,6 +304,10 @@ class CoordinationUI:
             vote_results = status.get("vote_results", {})
             selected_agent = status.get("selected_agent")
 
+            # Ensure selected_agent is not None to prevent UnboundLocalError
+            if selected_agent is None:
+                selected_agent = ""
+
             # if vote_results.get('vote_counts'):
             #     self._display_vote_results(vote_results)
             #     # Allow time for voting results to be visible
@@ -219,20 +315,72 @@ class CoordinationUI:
             #     time.sleep(1.0)
 
             # Get final presentation from winning agent
-            if (
-                self.enable_final_presentation
-                and selected_agent
-                and vote_results.get("vote_counts")
-            ):
-                print(f"\n🎤  Final Presentation from {selected_agent}:")
-                print("=" * 60)
+            if self.enable_final_presentation and selected_agent and vote_results.get("vote_counts"):
+                # Don't print - let the display handle it
+                # print(f"\n🎤  Final Presentation from {selected_agent}:")
+                # print("=" * 60)
 
                 presentation_content = ""
                 try:
-                    async for chunk in orchestrator.get_final_presentation(
-                        selected_agent, vote_results
-                    ):
+                    async for chunk in orchestrator.get_final_presentation(selected_agent, vote_results):
                         content = getattr(chunk, "content", "") or ""
+                        chunk_type = getattr(chunk, "type", "")
+
+                        # Use the same reasoning processing as main coordination
+                        if chunk_type in [
+                            "reasoning",
+                            "reasoning_done",
+                            "reasoning_summary",
+                            "reasoning_summary_done",
+                        ]:
+                            source = getattr(chunk, "source", selected_agent)
+
+                            reasoning_content = ""
+                            if chunk_type == "reasoning":
+                                # Stream reasoning delta as thinking content
+                                reasoning_delta = getattr(chunk, "reasoning_delta", "")
+                                if reasoning_delta:
+                                    # reasoning_content = reasoning_delta
+                                    reasoning_content = self._process_reasoning_content(chunk_type, reasoning_delta, source)
+                            elif chunk_type == "reasoning_done":
+                                # Complete reasoning text
+                                reasoning_text = getattr(chunk, "reasoning_text", "")
+                                if reasoning_text:
+                                    reasoning_content = f"\n🧠 [Reasoning Complete]\n{reasoning_text}\n"
+                                else:
+                                    reasoning_content = "\n🧠 [Reasoning Complete]\n"
+
+                                # Reset flag using helper method
+                                self._process_reasoning_content(chunk_type, reasoning_content, source)
+
+                                # Mark summary as complete - next summary can get a prefix
+                                reasoning_active_key = "_reasoning_active"
+                                if hasattr(self, reasoning_active_key):
+                                    delattr(self, reasoning_active_key)
+
+                            elif chunk_type == "reasoning_summary":
+                                # Stream reasoning summary delta
+                                summary_delta = getattr(chunk, "reasoning_summary_delta", "")
+                                if summary_delta:
+                                    reasoning_content = self._process_reasoning_summary(chunk_type, summary_delta, source)
+                            elif chunk_type == "reasoning_summary_done":
+                                # Complete reasoning summary
+                                summary_text = getattr(chunk, "reasoning_summary_text", "")
+                                if summary_text:
+                                    reasoning_content = f"\n📋 [Reasoning Summary Complete]\n{summary_text}\n"
+
+                                # Reset flag using helper method
+                                self._process_reasoning_summary(chunk_type, "", source)
+
+                                # Reset the prefix flag so next summary can get a prefix
+                                summary_active_key = f"_summary_active_{source}"
+                                if hasattr(self, summary_active_key):
+                                    delattr(self, summary_active_key)
+
+                            if reasoning_content:
+                                # Add to presentation content and display
+                                content = reasoning_content
+
                         if content:
                             # Ensure content is a string
                             if isinstance(content, list):
@@ -255,76 +403,53 @@ class CoordinationUI:
                             if self.display:
                                 try:
                                     await self._process_content(selected_agent, content)
-                                except Exception as e:
+                                except Exception:
                                     # Error processing presentation content - continue gracefully
                                     pass
-                                # Also print to console with flush using consistent timing with rich display
-                                self._print_with_flush(content)
+                                # Don't print - let the display handle it
+                                # self._print_with_flush(content)
                             else:
-                                # Simple print for non-display mode
+                                # Simple print for non-display mode (only if no display)
                                 print(content, end="", flush=True)
                 except AttributeError:
                     # get_final_presentation method doesn't exist or failed
-                    print(
-                        "Final presentation not available - using coordination result"
-                    )
+                    # print("Final presentation not available - using coordination result")
                     presentation_content = ""
 
                 final_answer = presentation_content
-                print("\n" + "=" * 60)
+                # Don't print - let the display handle it
+                # print("\n" + "=" * 60)
                 # Allow time for final presentation to be fully visible
                 time.sleep(1.5)
 
-            # Get the clean final answer from orchestrator's stored state (avoids token spacing issues)
+            # Get the final presentation content (synthesis) or fall back to stored answer
             orchestrator_final_answer = None
-            if (
-                selected_agent
-                and hasattr(orchestrator, "agent_states")
-                and selected_agent in orchestrator.agent_states
-            ):
+
+            # First try to get the synthesized final presentation content
+            if hasattr(orchestrator, "_final_presentation_content") and orchestrator._final_presentation_content:
+                orchestrator_final_answer = orchestrator._final_presentation_content.strip()
+            elif selected_agent and hasattr(orchestrator, "agent_states") and selected_agent in orchestrator.agent_states:
+                # Fall back to stored answer if no final presentation content
                 stored_answer = orchestrator.agent_states[selected_agent].answer
                 if stored_answer:
                     # Clean up the stored answer
-                    orchestrator_final_answer = (
-                        stored_answer.replace("\\", "\n").replace("**", "").strip()
-                    )
+                    orchestrator_final_answer = stored_answer.replace("\\", "\n").replace("**", "").strip()
 
             # Use orchestrator's clean answer if available, otherwise fall back to presentation
-            final_result = (
-                orchestrator_final_answer
-                if orchestrator_final_answer
-                else (final_answer if final_answer else full_response)
-            )
-            if final_result:
-                # print(f"\n🎯 FINAL COORDINATED ANSWER")
-                # print("=" * 80)
-                # print(f"{final_result.strip()}")
-                # print("=" * 80)
-
-                # Show which agent was selected
-                if selected_agent:
-                    print(f"✅ Selected by: {selected_agent}")
-                    if vote_results.get("vote_counts"):
-                        vote_summary = ", ".join(
-                            [
-                                f"{agent}: {count}"
-                                for agent, count in vote_results["vote_counts"].items()
-                            ]
-                        )
-                        print(f"🗳️ Vote results: {vote_summary}")
-                print()
+            final_result = orchestrator_final_answer if orchestrator_final_answer else (final_answer if final_answer else full_response)
 
             # Finalize session
             if self.logger:
-                session_info = self.logger.finalize_session(final_answer, success=True)
-                print(f"💾 Session log: {session_info['filename']}")
-                print(
-                    f"⏱️  Duration: {session_info['duration']:.1f}s | Chunks: {session_info['total_chunks']} | Events: {session_info['orchestrator_events']}"
+                session_info = self.logger.finalize_session(
+                    final_result if "final_result" in locals() else (final_answer if "final_answer" in locals() else ""),
+                    success=True,
                 )
+                print(f"💾 Session log: {session_info['filename']}")
+                print(f"⏱️  Duration: {session_info['duration']:.1f}s | Chunks: {session_info['total_chunks']} | Events: {session_info['orchestrator_events']}")
 
             return final_result
 
-        except Exception as e:
+        except Exception:
             if self.logger:
                 self.logger.finalize_session("", success=False)
             raise
@@ -336,20 +461,12 @@ class CoordinationUI:
                     await asyncio.wait_for(self._answer_timeout_task, timeout=1.0)
                 except (asyncio.TimeoutError, asyncio.CancelledError):
                     # If it takes too long or was cancelled, force flush
-                    if (
-                        hasattr(self, "_answer_buffer")
-                        and self._answer_buffer
-                        and not self._final_answer_shown
-                    ):
+                    if hasattr(self, "_answer_buffer") and self._answer_buffer and not self._final_answer_shown:
                         await self._flush_final_answer()
                     self._answer_timeout_task.cancel()
 
             # Final check to flush any remaining buffered answer
-            if (
-                hasattr(self, "_answer_buffer")
-                and self._answer_buffer
-                and not self._final_answer_shown
-            ):
+            if hasattr(self, "_answer_buffer") and self._answer_buffer and not self._final_answer_shown:
                 await self._flush_final_answer()
 
             # Small delay to ensure display updates are processed
@@ -358,24 +475,21 @@ class CoordinationUI:
             if self.display:
                 self.display.cleanup()
 
-            if selected_agent:
-                print(f"✅ Selected by: {selected_agent}")
-                if vote_results.get("vote_counts"):
-                    vote_summary = ", ".join(
-                        [
-                            f"{agent}: {count}"
-                            for agent, count in vote_results["vote_counts"].items()
-                        ]
-                    )
-                    print(f"🗳️ Vote results: {vote_summary}")
-            print()
+            # Don't print - display already showed this info
+            # if selected_agent:
+            #     print(f"✅ Selected by: {selected_agent}")
+            #     if vote_results.get("vote_counts"):
+            #         vote_summary = ", ".join([f"{agent}: {count}" for agent, count in vote_results["vote_counts"].items()])
+            #         print(f"🗳️ Vote results: {vote_summary}")
+            # print()
 
             if self.logger:
-                session_info = self.logger.finalize_session(final_answer, success=True)
-                print(f"💾 Session log: {session_info['filename']}")
-                print(
-                    f"⏱️  Duration: {session_info['duration']:.1f}s | Chunks: {session_info['total_chunks']} | Events: {session_info['orchestrator_events']}"
+                session_info = self.logger.finalize_session(
+                    final_result if "final_result" in locals() else (final_answer if "final_answer" in locals() else ""),
+                    success=True,
                 )
+                print(f"💾 Session log: {session_info['filename']}")
+                print(f"⏱️  Duration: {session_info['duration']:.1f}s | Chunks: {session_info['total_chunks']} | Events: {session_info['orchestrator_events']}")
 
     async def coordinate_with_context(
         self,
@@ -395,6 +509,12 @@ class CoordinationUI:
         Returns:
             Final coordinated response
         """
+        # Initialize variables that may be referenced in finally block
+        selected_agent = ""
+        vote_results = {}
+        final_result = ""
+        final_answer = ""
+
         # Reset display to ensure clean state for each coordination
         if self.display is not None:
             self.display.cleanup()
@@ -416,9 +536,7 @@ class CoordinationUI:
                 self.display = SimpleDisplay(self.agent_ids, **self.config)
             elif self.display_type == "rich_terminal":
                 if not is_rich_available():
-                    print(
-                        "⚠️  Rich library not available. Falling back to terminal display."
-                    )
+                    print("⚠️  Rich library not available. Falling back to terminal display.")
                     print("   Install with: pip install rich")
                     self.display = TerminalDisplay(self.agent_ids, **self.config)
                 else:
@@ -433,15 +551,9 @@ class CoordinationUI:
         log_filename = None
         if self.logger:
             # Add context info to session initialization
-            context_info = (
-                f"(with {len(messages)//2} previous exchanges)"
-                if len(messages) > 1
-                else ""
-            )
+            context_info = f"(with {len(messages)//2} previous exchanges)" if len(messages) > 1 else ""
             session_question = f"{question} {context_info}"
-            log_filename = self.logger.initialize_session(
-                session_question, self.agent_ids
-            )
+            log_filename = self.logger.initialize_session(session_question, self.agent_ids)
             monitoring = self.logger.get_monitoring_commands()
             print(f"📁 Real-time log: {log_filename}")
             print(f"💡 Monitor with: {monitoring['tail']}")
@@ -449,6 +561,11 @@ class CoordinationUI:
 
         self.display.initialize(question, log_filename)
 
+        # Initialize variables to avoid reference before assignment error in finally block
+        selected_agent = None
+        vote_results = {}
+        orchestrator_final_answer = None
+
         try:
             # Process coordination stream with conversation context
             full_response = ""
@@ -467,37 +584,87 @@ class CoordinationUI:
                         self.display.update_agent_status(source, status)
                     continue
 
-                # Handle builtin tool results
-                elif chunk_type == "builtin_tool_results":
-                    builtin_results = getattr(chunk, "builtin_tool_results", [])
-                    if builtin_results and source:
-                        for result in builtin_results:
-                            tool_type = result.get("tool_type", "unknown")
-                            status_result = result.get("status", "unknown")
-                            tool_msg = (
-                                f"🔧 [{tool_type.title()}] {status_result.title()}"
-                            )
-
-                            if tool_type in ["code_interpreter", "code_execution"]:
-                                code = result.get("code", "") or result.get(
-                                    "input", {}
-                                ).get("code", "")
-                                outputs = result.get("outputs")
-                                if code:
-                                    tool_msg += f" - Code: {code[:50]}{'...' if len(code) > 50 else ''}"
-                                if outputs:
-                                    tool_msg += f" - Result: {outputs}"
-                            elif tool_type == "web_search":
-                                query = result.get("query", "") or result.get(
-                                    "input", {}
-                                ).get("query", "")
-                                if query:
-                                    tool_msg += f" - Query: '{query}'"
-
-                            # Display as tool content for the specific agent
-                            await self._process_agent_content(source, tool_msg)
+                # Filter out debug chunks from display
+                elif chunk_type == "debug":
+                    # Log debug info but don't display it
+                    if self.logger:
+                        self.logger.log_chunk(source, content, chunk_type)
+                    continue
+
+                # Filter out mcp_status chunks - display via agent panel instead of console
+                elif chunk_type == "mcp_status":
+                    # Let the display handle MCP status via agent panel
+                    if source and source in self.agent_ids:
+                        self.display.update_agent_content(source, content, "tool")
+                    if self.logger:
+                        self.logger.log_chunk(source, content, chunk_type)
+                    continue
+
+                # builtin_tool_results handling removed - now handled as simple content
+
+                # Handle reasoning streams
+                elif chunk_type in [
+                    "reasoning",
+                    "reasoning_done",
+                    "reasoning_summary",
+                    "reasoning_summary_done",
+                ]:
+                    if source:
+                        reasoning_content = ""
+                        if chunk_type == "reasoning":
+                            # Stream reasoning delta as thinking content
+                            reasoning_delta = getattr(chunk, "reasoning_delta", "")
+                            if reasoning_delta:
+                                # reasoning_content = reasoning_delta
+                                reasoning_content = self._process_reasoning_content(chunk_type, reasoning_delta, source)
+                        elif chunk_type == "reasoning_done":
+                            # Complete reasoning text
+                            reasoning_text = getattr(chunk, "reasoning_text", "")
+                            if reasoning_text:
+                                reasoning_content = f"\n🧠 [Reasoning Complete]\n{reasoning_text}\n"
+                            else:
+                                reasoning_content = "\n🧠 [Reasoning Complete]\n"
+
+                            # Reset flag using helper method
+                            self._process_reasoning_content(chunk_type, reasoning_content, source)
+
+                            # Mark summary as complete - next summary can get a prefix
+                            reasoning_active_key = "_reasoning_active"
+                            if hasattr(self, reasoning_active_key):
+                                delattr(self, reasoning_active_key)
+                        elif chunk_type == "reasoning_summary":
+                            # Stream reasoning summary delta
+                            summary_delta = getattr(chunk, "reasoning_summary_delta", "")
+                            if summary_delta:
+                                reasoning_content = self._process_reasoning_summary(chunk_type, summary_delta, source)
+                        elif chunk_type == "reasoning_summary_done":
+                            # Complete reasoning summary
+                            summary_text = getattr(chunk, "reasoning_summary_text", "")
+                            if summary_text:
+                                reasoning_content = f"\n📋 [Reasoning Summary Complete]\n{summary_text}\n"
+
+                            # Reset flag using helper method
+                            self._process_reasoning_summary(chunk_type, "", source)
+
+                            # Mark summary as complete - next summary can get a prefix
+                            summary_active_key = f"_summary_active_{source}"
+                            if hasattr(self, summary_active_key):
+                                delattr(self, summary_active_key)
+
+                        if reasoning_content:
+                            # Display reasoning as thinking content
+                            self.display.update_agent_content(source, reasoning_content, "thinking")
+                            if self.logger:
+                                self.logger.log_agent_content(source, reasoning_content, "reasoning")
                     continue
 
+                # Reset reasoning prefix state when final presentation starts
+                if chunk_type == "status" and "presenting final answer" in content:
+                    # Clear all summary active flags for final presentation
+                    for attr_name in list(vars(self).keys()):
+                        if attr_name.startswith("_summary_active_"):
+                            delattr(self, attr_name)
+
                 if content:
                     full_response += content
 
@@ -513,6 +680,10 @@ class CoordinationUI:
             vote_results = status.get("vote_results", {})
             selected_agent = status.get("selected_agent")
 
+            # Ensure selected_agent is not None to prevent UnboundLocalError
+            if selected_agent is None:
+                selected_agent = ""
+
             # if vote_results.get('vote_counts'):
             #     self._display_vote_results(vote_results)
             #     # Allow time for voting results to be visible
@@ -520,20 +691,72 @@ class CoordinationUI:
             #     time.sleep(1.0)
 
             # Get final presentation from winning agent
-            if (
-                self.enable_final_presentation
-                and selected_agent
-                and vote_results.get("vote_counts")
-            ):
-                print(f"\n🎤 Final Presentation from {selected_agent}:")
-                print("=" * 60)
+            if self.enable_final_presentation and selected_agent and vote_results.get("vote_counts"):
+                # Don't print - let the display handle it
+                # print(f"\n🎤 Final Presentation from {selected_agent}:")
+                # print("=" * 60)
 
                 presentation_content = ""
                 try:
-                    async for chunk in orchestrator.get_final_presentation(
-                        selected_agent, vote_results
-                    ):
+                    async for chunk in orchestrator.get_final_presentation(selected_agent, vote_results):
                         content = getattr(chunk, "content", "") or ""
+                        chunk_type = getattr(chunk, "type", "")
+
+                        # Use the same reasoning processing as main coordination
+                        if chunk_type in [
+                            "reasoning",
+                            "reasoning_done",
+                            "reasoning_summary",
+                            "reasoning_summary_done",
+                        ]:
+                            source = getattr(chunk, "source", selected_agent)
+
+                            reasoning_content = ""
+                            if chunk_type == "reasoning":
+                                # Stream reasoning delta as thinking content
+                                reasoning_delta = getattr(chunk, "reasoning_delta", "")
+                                if reasoning_delta:
+                                    # reasoning_content = reasoning_delta
+                                    reasoning_content = self._process_reasoning_content(chunk_type, reasoning_delta, source)
+                            elif chunk_type == "reasoning_done":
+                                # Complete reasoning text
+                                reasoning_text = getattr(chunk, "reasoning_text", "")
+                                if reasoning_text:
+                                    reasoning_content = f"\n🧠 [Reasoning Complete]\n{reasoning_text}\n"
+                                else:
+                                    reasoning_content = "\n🧠 [Reasoning Complete]\n"
+
+                                # Reset flag using helper method
+                                self._process_reasoning_content(chunk_type, reasoning_content, source)
+
+                                # Mark summary as complete - next summary can get a prefix
+                                reasoning_active_key = "_reasoning_active"
+                                if hasattr(self, reasoning_active_key):
+                                    delattr(self, reasoning_active_key)
+
+                            elif chunk_type == "reasoning_summary":
+                                # Stream reasoning summary delta
+                                summary_delta = getattr(chunk, "reasoning_summary_delta", "")
+                                if summary_delta:
+                                    reasoning_content = self._process_reasoning_summary(chunk_type, summary_delta, source)
+                            elif chunk_type == "reasoning_summary_done":
+                                # Complete reasoning summary
+                                summary_text = getattr(chunk, "reasoning_summary_text", "")
+                                if summary_text:
+                                    reasoning_content = f"\n📋 [Reasoning Summary Complete]\n{summary_text}\n"
+
+                                # Reset flag using helper method
+                                self._process_reasoning_summary(chunk_type, "", source)
+
+                                # Reset the prefix flag so next summary can get a prefix
+                                summary_active_key = f"_summary_active_{source}"
+                                if hasattr(self, summary_active_key):
+                                    delattr(self, summary_active_key)
+
+                            if reasoning_content:
+                                # Add to presentation content and display
+                                content = reasoning_content
+
                         if content:
                             # Ensure content is a string
                             if isinstance(content, list):
@@ -552,8 +775,8 @@ class CoordinationUI:
                                     getattr(chunk, "type", "presentation"),
                                 )
 
-                            # Stream presentation to console with consistent flush timing
-                            self._print_with_flush(content)
+                            # Don't print - let the display handle it
+                            # self._print_with_flush(content)
 
                             # Update display
                             await self._process_content(selected_agent, content)
@@ -561,65 +784,40 @@ class CoordinationUI:
                             if getattr(chunk, "type", "") == "done":
                                 break
 
-                except Exception as e:
-                    print(f"\n❌ Error during final presentation: {e}")
+                except Exception:
+                    # Don't print - let the display handle errors
+                    # print(f"\n❌ Error during final presentation: {e}")
                     presentation_content = full_response  # Fallback
 
                 final_answer = presentation_content
-                print("\n" + "=" * 60)
+                # Don't print - let the display handle it
+                # print("\n" + "=" * 60)
                 # Allow time for final presentation to be fully visible
                 time.sleep(1.5)
 
             # Get the clean final answer from orchestrator's stored state
             orchestrator_final_answer = None
-            if (
-                selected_agent
-                and hasattr(orchestrator, "agent_states")
-                and selected_agent in orchestrator.agent_states
-            ):
+            if selected_agent and hasattr(orchestrator, "agent_states") and selected_agent in orchestrator.agent_states:
                 stored_answer = orchestrator.agent_states[selected_agent].answer
                 if stored_answer:
                     # Clean up the stored answer
-                    orchestrator_final_answer = (
-                        stored_answer.replace("\\", "\n").replace("**", "").strip()
-                    )
+                    orchestrator_final_answer = stored_answer.replace("\\", "\n").replace("**", "").strip()
 
             # Use orchestrator's clean answer if available, otherwise fall back to presentation
-            final_result = (
-                orchestrator_final_answer
-                if orchestrator_final_answer
-                else (final_answer if final_answer else full_response)
-            )
-            if final_result:
-                # print(f"\n🎯 FINAL COORDINATED ANSWER")
-                # print("=" * 80)
-                # print(f"{final_result.strip()}")
-                # print("=" * 80)
-
-                # Show which agent was selected
-                if selected_agent:
-                    print(f"✅ Selected by: {selected_agent}")
-                    if vote_results.get("vote_counts"):
-                        vote_summary = ", ".join(
-                            [
-                                f"{agent}: {count}"
-                                for agent, count in vote_results["vote_counts"].items()
-                            ]
-                        )
-                        print(f"🗳️ Vote results: {vote_summary}")
-                print()
+            final_result = orchestrator_final_answer if orchestrator_final_answer else (final_answer if final_answer else full_response)
 
             # Finalize session
             if self.logger:
-                session_info = self.logger.finalize_session(final_answer, success=True)
-                print(f"💾 Session log: {session_info['filename']}")
-                print(
-                    f"⏱️  Duration: {session_info['duration']:.1f}s | Chunks: {session_info['total_chunks']} | Events: {session_info['orchestrator_events']}"
+                session_info = self.logger.finalize_session(
+                    final_result if "final_result" in locals() else (final_answer if "final_answer" in locals() else ""),
+                    success=True,
                 )
+                print(f"💾 Session log: {session_info['filename']}")
+                print(f"⏱️  Duration: {session_info['duration']:.1f}s | Chunks: {session_info['total_chunks']} | Events: {session_info['orchestrator_events']}")
 
             return final_result
 
-        except Exception as e:
+        except Exception:
             if self.logger:
                 self.logger.finalize_session("", success=False)
             raise
@@ -631,20 +829,12 @@ class CoordinationUI:
                     await asyncio.wait_for(self._answer_timeout_task, timeout=1.0)
                 except (asyncio.TimeoutError, asyncio.CancelledError):
                     # If it takes too long or was cancelled, force flush
-                    if (
-                        hasattr(self, "_answer_buffer")
-                        and self._answer_buffer
-                        and not self._final_answer_shown
-                    ):
+                    if hasattr(self, "_answer_buffer") and self._answer_buffer and not self._final_answer_shown:
                         await self._flush_final_answer()
                     self._answer_timeout_task.cancel()
 
             # Final check to flush any remaining buffered answer
-            if (
-                hasattr(self, "_answer_buffer")
-                and self._answer_buffer
-                and not self._final_answer_shown
-            ):
+            if hasattr(self, "_answer_buffer") and self._answer_buffer and not self._final_answer_shown:
                 await self._flush_final_answer()
 
             # Small delay to ensure display updates are processed
@@ -655,7 +845,7 @@ class CoordinationUI:
 
     def _display_vote_results(self, vote_results: Dict[str, Any]):
         """Display voting results in a formatted table."""
-        print(f"\n🗳️  VOTING RESULTS")
+        print("\n🗳️  VOTING RESULTS")
         print("=" * 50)
 
         vote_counts = vote_results.get("vote_counts", {})
@@ -665,19 +855,15 @@ class CoordinationUI:
 
         # Display vote counts
         if vote_counts:
-            print(f"\n📊 Vote Count:")
-            for agent_id, count in sorted(
-                vote_counts.items(), key=lambda x: x[1], reverse=True
-            ):
+            print("\n📊 Vote Count:")
+            for agent_id, count in sorted(vote_counts.items(), key=lambda x: x[1], reverse=True):
                 winner_mark = "🏆" if agent_id == winner else "  "
                 tie_mark = " (tie-broken)" if is_tie and agent_id == winner else ""
-                print(
-                    f"   {winner_mark} {agent_id}: {count} vote{'s' if count != 1 else ''}{tie_mark}"
-                )
+                print(f"   {winner_mark} {agent_id}: {count} vote{'s' if count != 1 else ''}{tie_mark}")
 
         # Display voter details
         if voter_details:
-            print(f"\n🔍 Vote Details:")
+            print("\n🔍 Vote Details:")
             for voted_for, voters in voter_details.items():
                 print(f"   → {voted_for}:")
                 for voter_info in voters:
@@ -687,9 +873,7 @@ class CoordinationUI:
 
         # Display tie-breaking info
         if is_tie:
-            print(
-                f"\n⚖️  Tie broken by agent registration order (orchestrator setup order)"
-            )
+            print("\n⚖️  Tie broken by agent registration order (orchestrator setup order)")
 
         # Display summary stats
         total_votes = vote_results.get("total_votes", 0)
@@ -719,11 +903,7 @@ class CoordinationUI:
                     "Coordinating agents, please wait",
                 ]
             ):
-                event = (
-                    f"🔄 {source}: {clean_line}"
-                    if source and source not in ["coordination_hub", "orchestrator"]
-                    else f"🔄 {clean_line}"
-                )
+                event = f"🔄 {source}: {clean_line}" if source and source not in ["coordination_hub", "orchestrator"] else f"🔄 {clean_line}"
                 self.display.add_orchestrator_event(event)
                 if self.logger:
                     self.logger.log_orchestrator_event(event)
@@ -784,7 +964,7 @@ class CoordinationUI:
             pass
 
         # Handle coordination events (provided answer, votes)
-        elif any(marker in content for marker in ["✅", "🗳️", "🔄", "❌"]):
+        elif any(marker in content for marker in ["✅", "🗳️", "🔄", "❌", "⚠️"]):
             clean_line = content.replace("**", "").replace("##", "").strip()
             if clean_line and not any(
                 skip in clean_line
@@ -817,11 +997,7 @@ class CoordinationUI:
         ):
             # Extract clean final answer content
             clean_content = content.strip()
-            if (
-                clean_content
-                and not clean_content.startswith("---")
-                and not clean_content.startswith("*Coordinated by")
-            ):
+            if clean_content and not clean_content.startswith("---") and not clean_content.startswith("*Coordinated by"):
                 # Add to buffer
                 if self._answer_buffer:
                     self._answer_buffer += " " + clean_content
@@ -833,9 +1009,7 @@ class CoordinationUI:
                     self._answer_timeout_task.cancel()
 
                 # Set a timeout to flush the answer (in case streaming stops)
-                self._answer_timeout_task = asyncio.create_task(
-                    self._schedule_final_answer_flush()
-                )
+                self._answer_timeout_task = asyncio.create_task(self._schedule_final_answer_flush())
 
                 # Create event for this chunk but don't call show_final_answer yet
                 status = self.orchestrator.get_status()
@@ -846,19 +1020,36 @@ class CoordinationUI:
 
                 # Only create final event for first chunk to avoid spam
                 if self._answer_buffer == clean_content:  # First chunk
-                    if vote_counts:
-                        vote_summary = ", ".join(
-                            [
-                                f"{agent}: {count} vote{'s' if count != 1 else ''}"
-                                for agent, count in vote_counts.items()
-                            ]
-                        )
-                        tie_info = (
-                            " (tie-broken by registration order)" if is_tie else ""
-                        )
-                        event = f"🎯 FINAL: {selected_agent} selected ({vote_summary}{tie_info}) → [buffering...]"
+                    # Check if orchestrator timed out
+                    orchestrator_timeout = getattr(self.orchestrator, "is_orchestrator_timeout", False)
+
+                    if selected_agent == "Unknown" or selected_agent is None:
+                        if orchestrator_timeout:
+                            # Even with timeout, try to select agent from available votes
+                            if vote_counts:
+                                # Find agent with most votes
+                                max_votes = max(vote_counts.values())
+                                tied_agents = [agent for agent, count in vote_counts.items() if count == max_votes]
+                                # Use first tied agent (following orchestrator's tie-breaking logic)
+                                timeout_selected_agent = tied_agents[0] if tied_agents else None
+                                if timeout_selected_agent:
+                                    vote_summary = ", ".join([f"{agent}: {count}" for agent, count in vote_counts.items()])
+                                    tie_info = " (tie-broken by registration order)" if len(tied_agents) > 1 else ""
+                                    event = f"🎯 FINAL: {timeout_selected_agent} selected from partial votes ({vote_summary}{tie_info}) → orchestrator timeout → [buffering...]"
+                                else:
+                                    event = "🎯 FINAL: None selected → orchestrator timeout (no agents completed voting in time) → [buffering...]"
+                            else:
+                                event = "🎯 FINAL: None selected → orchestrator timeout (no agents completed voting in time) → [buffering...]"
+                        else:
+                            event = "🎯 FINAL: None selected → [buffering...]"
+                    elif vote_counts:
+                        vote_summary = ", ".join([f"{agent}: {count} vote{'s' if count != 1 else ''}" for agent, count in vote_counts.items()])
+                        tie_info = " (tie-broken by registration order)" if is_tie else ""
+                        timeout_info = " (despite timeout)" if orchestrator_timeout else ""
+                        event = f"🎯 FINAL: {selected_agent} selected ({vote_summary}{tie_info}){timeout_info} → [buffering...]"
                     else:
-                        event = f"🎯 FINAL: {selected_agent} selected → [buffering...]"
+                        timeout_info = " (despite timeout)" if orchestrator_timeout else ""
+                        event = f"🎯 FINAL: {selected_agent} selected{timeout_info} → [buffering...]"
 
                     self.display.add_orchestrator_event(event)
                     if self.logger:
@@ -880,10 +1071,8 @@ class CoordinationUI:
 
 
 # Convenience functions for common use cases
-async def coordinate_with_terminal_ui(
-    orchestrator, question: str, enable_final_presentation: bool = False, **kwargs
-) -> str:
-    """Quick coordination with terminal UI and logging.
+async def coordinate_with_terminal_ui(orchestrator, question: str, enable_final_presentation: bool = False, **kwargs) -> str:
+    """Quick coordination with terminal UI.
 
     Args:
         orchestrator: MassGen orchestrator instance
@@ -902,10 +1091,8 @@ async def coordinate_with_terminal_ui(
     return await ui.coordinate(orchestrator, question)
 
 
-async def coordinate_with_simple_ui(
-    orchestrator, question: str, enable_final_presentation: bool = False, **kwargs
-) -> str:
-    """Quick coordination with simple UI and logging.
+async def coordinate_with_simple_ui(orchestrator, question: str, enable_final_presentation: bool = False, **kwargs) -> str:
+    """Quick coordination with simple UI.
 
     Args:
         orchestrator: MassGen orchestrator instance
@@ -923,10 +1110,8 @@ async def coordinate_with_simple_ui(
     return await ui.coordinate(orchestrator, question)
 
 
-async def coordinate_with_rich_ui(
-    orchestrator, question: str, enable_final_presentation: bool = False, **kwargs
-) -> str:
-    """Quick coordination with rich terminal UI and logging.
+async def coordinate_with_rich_ui(orchestrator, question: str, enable_final_presentation: bool = False, **kwargs) -> str:
+    """Quick coordination with rich terminal UI.
 
     Args:
         orchestrator: MassGen orchestrator instance