siada-cli 1.5.3__tar.gz → 1.5.6__tar.gz

{siada_cli-1.5.3 → siada_cli-1.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: siada-cli
-Version: 1.5.3
+Version: 1.5.6
 Summary: Siada CLI is a Ai Pair Programming Tool in terminal
 License: Apache-2.0
 License-File: LICENSE
@@ -20,6 +20,7 @@ Requires-Dist: browsergym (>=0.14.2,<0.15.0)
 Requires-Dist: click (>=8.2.1,<9.0.0)
 Requires-Dist: configargparse (>=1.7,<2.0.0)
 Requires-Dist: diskcache (==5.6.3)
+Requires-Dist: drawille (>=0.1.0,<1.0.0)
 Requires-Dist: fastapi (>=0.110.0,<1.0.0)
 Requires-Dist: gitpython (>=3.1.0,<4.0.0)
 Requires-Dist: grep-ast (>=0.9.0,<1.0.0)
@@ -82,7 +83,7 @@ With Siada CLI you can:
    ```
 2. Install siada-cli
    ```bash
-   uv tool install --force --python python3.12 --with pip siada-cli@latest --no-build-package pyarrow
+   uv tool install --force --python python3.12 --compile --with pip siada-cli@latest
    ```
    If the siada-cli directory is not present on the PATH, run the follow command to update the shell
    ```bash

{siada_cli-1.5.3 → siada_cli-1.5.6}/README.md

@@ -29,7 +29,7 @@ With Siada CLI you can:
    ```
 2. Install siada-cli
    ```bash
-   uv tool install --force --python python3.12 --with pip siada-cli@latest --no-build-package pyarrow
+   uv tool install --force --python python3.12 --compile --with pip siada-cli@latest
    ```
    If the siada-cli directory is not present on the PATH, run the follow command to update the shell
    ```bash

{siada_cli-1.5.3 → siada_cli-1.5.6}/agent_config.yaml

@@ -50,7 +50,7 @@ agents:
 
 # LLM Configuration
 llm_config:
-  provider: "li"                    # Optional： "li" ， "openrouter", "default"
+  provider: "openrouter"                    # Optional： "li" ， "openrouter", "default"
   model_name: "claude-sonnet-4.5"
   repo_map_tokens: 8192                     # repo map max token
   repo_map_mul_no_files: 16                 # Multiple without chat files

{siada_cli-1.5.3 → siada_cli-1.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "siada-cli"
-version = "1.5.3"
+version = "1.5.6"
 description = "Siada CLI is a Ai Pair Programming Tool in terminal"
 packages = [{include = "siada"}, {include = "agent_config.yaml"}]
 include = ["agent_config.yaml"]
@@ -17,7 +17,7 @@ classifiers = [
 ]
 
 [tool.poetry.scripts]
-siada-cli = "siada.entrypoint.siadahub:main"
+siada-cli = "siada.entrypoint.siadahub:main"  
 [tool.poetry.dependencies]
 python = "^3.12"
 fastapi = ">=0.110.0,<1.0.0"
@@ -55,6 +55,7 @@ pandas = ">=2.0.0,<3.0.0"
 scikit-learn = ">=1.3.0,<2.0.0"
 browsergym = "^0.14.2"
 gymnasium = "^1.2.0"
+drawille = ">=0.1.0,<1.0.0"
 
 
 [tool.poetry.group.dev.dependencies]

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/agent_hub/coder/prompt/base/prompt_builder.py

@@ -1,3 +1,4 @@
+
 def build_system_prompt(intro: str, tool_use: str, capabilities: str, rules: str, objective: str, user_memory: str = None, preferred_language: str = "en", agent_name: str = None) -> str:
     """
     Common function for building system prompts
@@ -39,7 +40,7 @@ def build_system_prompt(intro: str, tool_use: str, capabilities: str, rules: str
     return base_prompt
 
 
-def _get_language_instruction(preferred_language: str, agent_name: str = None) -> str:
+def _get_language_instruction(preferred_language: str='en', agent_name: str = None) -> str:
     """
     Get language preference instruction based on user's choice.
     Only returns instruction if the preferred language differs from the agent's default language.
@@ -54,8 +55,18 @@ def _get_language_instruction(preferred_language: str, agent_name: str = None) -
     from siada.config.language_config import get_agent_default_language
     
     # Get the default language for this agent
-    default_language = get_agent_default_language(agent_name) if agent_name else "en"
+    from siada.config.language_config import DEFAULT_LANGUAGE
+    default_language = get_agent_default_language(agent_name) if agent_name else DEFAULT_LANGUAGE
     
+#     if preferred_language == None:
+#         return f"""====
+
+# PREFERRED LANGUAGE
+
+# Use the same language as the user to speak.
+
+# """
+
     # Only return instruction if preferred language differs from default
     if preferred_language != default_language:
         return f"""====

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/agent_hub/coder/prompt/base/rules.py

@@ -23,7 +23,8 @@ def get_rules_section(cwd: str, os_name: str, home_dir: str, interactive_mode: b
 - When using the regex_search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the regex_search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use the view command of the edit_file tool to examine the full context of interesting matches before using replace_in_file to make informed changes.
 - When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
 - When you want to modify a file, use the str_replace or insert command of the edit_file tool directly with the desired changes. You do not need to display the changes before using the tool.
-- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. 
+- NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one. This includes markdown files.
+- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task.
 - The user may provide a file's contents directly in their message, in which case you shouldn't use the tool to get the file contents again since you already have it.
 - Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.
 - You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/agent_hub/coder/prompt/code_gen_prompt.py

@@ -6,7 +6,7 @@ from .base.rules import get_rules_section
 from .base.prompt_builder import build_system_prompt
 
 
-def get_system_prompt(cwd: str = "/default/path", interactive_mode: bool = True, user_memory: str = None, preferred_language: str = "en", agent_name: str = None) -> str:
+def get_system_prompt(cwd: str = "/default/path", interactive_mode: bool = True, user_memory: str = None, preferred_language: str = None, agent_name: str = None) -> str:
     """
     生成系统提示词
 

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/agent_hub/context_filter/api_message_transfer_filter.py

@@ -496,6 +496,13 @@ class ApiMessageTransferFilter:
             "model": model,
             "messages": _build_compact_messages(history_to_compact=history_to_compact),
         }
+        
+        # Only add empty tools list for Anthropic/Claude models with default provider to avoid litellm error
+        if provider == "default" and (
+            "anthropic" in model.lower() or "claude" in model.lower()
+        ):
+            complete_kwargs["tools"] = []
+        
         response = await llm_client.completion(**complete_kwargs)
 
         if response and response.choices and response.choices[0].message:

siada_cli-1.5.6/siada/agent_hub/hooks/processors/llm_spinner_processor.py

@@ -0,0 +1,153 @@
+"""
+LLM Spinner Processor
+
+Provides visual feedback during LLM calls by displaying a waiting spinner.
+"""
+
+from typing import Optional
+from agents import Agent, ModelResponse, AgentHooks, TContext, TResponseInputItem, RunContextWrapper
+from siada.foundation.code_agent_context import CodeAgentContext
+from siada.support.spinner import WaitingSpinner
+
+
+class LLMSpinnerProcessor(AgentHooks):
+    """
+    Processor that displays a waiting spinner during LLM calls.
+    
+    This processor:
+    - Starts a spinner when LLM call begins (on_llm_start)
+    - Stops the spinner when LLM call completes (on_llm_end)
+    """
+    
+    def __init__(self, spinner_text: str = "Waiting for LLM...", text_color: str = "#79B8FF"):
+        """
+        Initialize the LLM spinner processor.
+        
+        Args:
+            spinner_text: Text to display with the spinner
+            text_color: Color of the spinner text (hex or color name)
+        """
+        self.spinner_text = spinner_text
+        self.text_color = text_color
+        self.spinner: Optional[WaitingSpinner] = None
+
+    async def on_llm_start(
+        self,
+        context: RunContextWrapper[CodeAgentContext],
+        agent: Agent[TContext],
+        system_prompt: Optional[str],
+        input_items: list[TResponseInputItem],
+    ) -> None:
+        """
+        Called just before invoking the LLM.
+        Starts the waiting spinner and injects it into session for external access.
+        Only starts spinner in interactive mode.
+        """
+        # Only start spinner if we're in interactive mode
+        if hasattr(context.context, 'session') and context.context.session and context.context.session.siada_config:
+            running_config = getattr(context.context.session, 'siada_config', None)
+            
+            # Check if we're in interactive mode
+            if not running_config or not getattr(running_config, 'interactive', True):
+                # Non-interactive mode, skip spinner
+                return
+            
+            # Get agent name for personalized message
+            agent_name = getattr(context.context.session.siada_config, 'agent_name', 'Agent')
+            spinner_text = f"Thinking ..."
+            
+            # Get IO instance to pass to spinner for panel status checking
+            io_instance = getattr(running_config, 'io', None) if running_config else None
+            
+            # Create and start spinner with IO instance
+            self.spinner = WaitingSpinner(spinner_text, text_color=self.text_color, io_instance=io_instance)
+            self.spinner.start()
+            
+            # Inject spinner into session state for external access
+            # This allows _stop_waiting_spinner() in conversation_turn.py to stop it
+            # when the first stream data arrives
+            context.context.session.state.spinner = self.spinner
+
+    async def on_llm_end(
+        self,
+        context: RunContextWrapper[CodeAgentContext],
+        agent: Agent[TContext],
+        response: ModelResponse,
+    ) -> None:
+        """
+        Called immediately after the LLM call returns.
+        Stops the waiting spinner with fallback cleanup.
+        
+        This method ensures spinner is stopped in all cases:
+        1. Stops self.spinner (processor's own reference)
+        2. Stops session.state.spinner (external reference used by conversation_turn)
+        3. Stops session.spinner (legacy reference if exists)
+        """
+        # Stop processor's own spinner reference
+        if self.spinner is not None:
+            try:
+                self.spinner.stop()
+            except Exception:
+                pass  # Ignore stop errors
+            finally:
+                self.spinner = None
+        
+        # Fallback: Also stop spinner in session.state (used by conversation_turn._stop_waiting_spinner)
+        if hasattr(context.context, 'session') and context.context.session:
+            session = context.context.session
+            
+            # Stop session.state.spinner
+            if hasattr(session, 'state') and hasattr(session.state, 'spinner'):
+                spinner = session.state.spinner
+                if spinner:
+                    try:
+                        spinner.stop()
+                    except Exception:
+                        pass  # Ignore stop errors
+                    finally:
+                        session.state.spinner = None
+            
+            # Stop session.spinner (legacy reference)
+            if hasattr(session, 'spinner') and session.spinner:
+                try:
+                    session.spinner.stop()
+                except Exception:
+                    pass  # Ignore stop errors
+                finally:
+                    session.spinner = None
+
+    async def on_agent_start(
+        self,
+        context: RunContextWrapper[CodeAgentContext],
+        agent: Agent[TContext],
+    ) -> None:
+        """Called when an agent starts execution."""
+        pass
+
+    async def on_agent_end(
+        self,
+        context: RunContextWrapper[CodeAgentContext],
+        agent: Agent[TContext],
+        output: any,
+    ) -> None:
+        """Called when an agent completes execution."""
+        pass
+
+    async def on_tool_start(
+        self,
+        context: RunContextWrapper[CodeAgentContext],
+        agent: Agent[TContext],
+        tool: any,
+    ) -> None:
+        """Called before a tool is executed."""
+        pass
+
+    async def on_tool_end(
+        self,
+        context: RunContextWrapper[CodeAgentContext],
+        agent: Agent[TContext],
+        tool: any,
+        result: str,
+    ) -> None:
+        """Called after a tool completes execution."""
+        pass

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/agent_hub/hooks/siada_agent_hooks.py

@@ -2,6 +2,7 @@ from typing import Optional, List, Any
 from agents import Agent, ModelResponse, AgentHooks, TContext, TResponseInputItem, RunContextWrapper, Tool
 from siada.foundation.code_agent_context import CodeAgentContext
 from siada.agent_hub.hooks.agent_processors.context_track_processor import ContextTrackProcessor
+from siada.agent_hub.hooks.processors.llm_spinner_processor import LLMSpinnerProcessor
 
 
 class SiadaAgentHooks(AgentHooks):
@@ -23,6 +24,7 @@ class SiadaAgentHooks(AgentHooks):
             # Default processors
             self.processors = [
                 ContextTrackProcessor(),
+                LLMSpinnerProcessor(),  # Add spinner for LLM calls
                 # Add more processors here as needed
             ]
         else:
@@ -118,4 +120,4 @@ class SiadaAgentHooks(AgentHooks):
             processor: The AgentHooks processor to remove
         """
         if processor in self.processors:
-            self.processors.remove(processor)
+            self.processors.remove(processor)

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/entrypoint/interaction/controller.py

@@ -8,6 +8,7 @@ Separates core interaction logic from main entry point for better code organizat
 import time
 import asyncio
 import threading
+from regex import T
 from siada.session.session_models import RunningSession
 from siada import __version__
 from siada.entrypoint.interaction.running_config import RunningConfig
@@ -44,6 +45,7 @@ class Controller:
         self._preload_success = False
         # Pre-load agent class asynchronously to optimize first-time execution
         self._start_preload_agent()
+        self.need_show_announcements_welcome_panel:bool = True 
     
     def _start_preload_agent(self):
         """
@@ -98,7 +100,7 @@ class Controller:
             if show_spinner and not self._preload_complete.is_set():
                 if self.config.io and self.config.io.pretty:
                     message = f"Loading {self.config.agent_name} agent..."
-                    spinner = WaitingSpinner(message, text_color="cyan")
+                    spinner = WaitingSpinner(message, text_color="#79B8FF")
                     spinner.start()
             
             if self._preload_complete.wait(timeout=timeout):
@@ -151,7 +153,7 @@ class Controller:
 
     def run(self) -> int:
         session = self.session
-        display_rule = True
+        display_rule = False
         pending_input = None  # Pending input to process in next iteration
 
         while True:
@@ -235,8 +237,14 @@ class Controller:
                 break
 
     def get_announcements(self):
+        import os
+        
         lines = []
-        lines.append(f"Siada CLI v{__version__} supported by Li Auto")
+        # lines.append(f"Siada CLI v{__version__} supported by Li Auto")
+        
+        # Add current working directory
+        current_dir = os.getcwd()
+        lines.append(f"Working Directory: {current_dir}")
 
         output = f"Agent: {self.config.agent_name}, Provider: {self.config.llm_config.provider}, Model: {self.config.llm_config.model_name}"
 
@@ -259,8 +267,23 @@ class Controller:
         return lines
 
     def show_announcements(self):
-        for line in self.get_announcements():
-            self.config.io.print_info(line)
+            # Clear terminal using system clear command
+        import os 
+        os.system('clear' if os.name != 'nt' else 'cls')
+        if self.need_show_announcements_welcome_panel:
+            # only once
+            self.need_show_announcements_welcome_panel = False
+            self.show_announcements_welcome_panel()  
+        else:
+            for line in self.get_announcements():
+                self.config.io.print_info(line)
+    
+    def show_announcements_welcome_panel(self, console: Console = None):
+        from siada.io.banner import BannerDisplay
+
+        announcements = self.get_announcements()
+        BannerDisplay.show_welcome_panel(announcements=announcements, console=console
+                                         , siada_version=f"Siada CLI v{__version__}")
 
     def keyboard_interrupt(self):
         # Ensure cursor is visible on exit

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/entrypoint/interaction/running_config.py

@@ -37,4 +37,5 @@ class RunningConfig:
     mcp_service = None  # MCP service instance (will be initialized later)
     auto_compact: bool = True  # Enable automatic context compression
     siadaignore_controller: Optional[SiadaIgnoreController] = None  # SiadaIgnore controller for file access control
-    preferred_language: str = "en"  # Preferred language for AI responses: "en" (English) or "zh-CN" (Chinese)
+    preferred_language: str = None  # Preferred language for AI responses: "en" (English) or "zh-CN" (Chinese)
+    startup_warning: Optional[str] = None  # Warning message to display at startup (for Textual mode)

{siada_cli-1.5.3 → siada_cli-1.5.6}/siada/entrypoint/interaction/turn/conversation_turn.py

@@ -39,11 +39,11 @@ REASONING_TAG = "thinking-content-" + "7bbeb8e1441453ad999a0bbba8a46d4b"
 SPLIT_TAG = "\n--------------\n"
 # Output formatting
 
-REASONING_START = "► **THINKING**"
+REASONING_START = "▶ **THINKING**" # ►
 
-REASONING_END = "► **ANSWER**"
+REASONING_END = "▶ **ANSWER**"
 
-TOOL_CALL_START = "► **TOOL USE**"
+TOOL_CALL_START = "▶ **TOOL USE**"
 
 
 class ConversationTurn(RunTurn):
@@ -267,7 +267,7 @@ class ConversationTurn(RunTurn):
                     ):
                         if not self.got_reasoning_part and stream_data.delta:
                             self.got_reasoning_part = True
-                            self.print_split_line()
+                            # self.print_split_line()
                             delta_text = f"\n{REASONING_START}\n\n{stream_data.delta}"
                             self.response_content += delta_text
                         else:
@@ -289,8 +289,8 @@ class ConversationTurn(RunTurn):
                     elif isinstance(stream_data, ResponseTextDeltaEvent):
                         if not self.got_content_part and stream_data.delta:
                             self.got_content_part = True
-                            if not self.got_reasoning_part:
-                                self.print_split_line()
+                            # if not self.got_reasoning_part:
+                            #     self.print_split_line()
                             delta_text = f"\n\n{REASONING_END}\n\n{stream_data.delta}"
                             self.response_content += delta_text
                         else:
@@ -368,10 +368,19 @@ class ConversationTurn(RunTurn):
                                     ]
 
                             self.current_active_call_id = call_id
-                            self.print_split_line()
-                            self.config.io.print_tool_call(
-                                f"{TOOL_CALL_START}\n\nSiada wants to use the tool: {tool_name}\n"
+                            # self.print_split_line()
+                            
+                            # Stage 1: Print tool name (use append=False to avoid accumulating the header)
+                            self.config.io.print_tool_call_all_stages(
+                                f"Siada wants to use the tool: {tool_name}.\n",
+                                final=False,
+                                append=True
                             )
+                            
+                            # Original method (commented out for reference)
+                            # self.config.io.print_tool_call(
+                            #     f"{TOOL_CALL_START}\n\nSiada wants to use the tool: {tool_name}\n"
+                            # )
 
                     elif isinstance(
                         stream_data, ResponseFunctionCallArgumentsDeltaEvent
@@ -387,35 +396,35 @@ class ConversationTurn(RunTurn):
                         )
 
                         # if supports streaming, update the tool call mdstream
-                        if tool_call_formatter.supports_streaming():
-                            content, is_complete = tool_call_formatter.format_input(
-                                self.current_active_call_id,
-                                self.tool_calls[self.current_active_call_id]["name"],
-                                self.tool_calls[self.current_active_call_id][
-                                    "arguments"
-                                ],
-                            )
-
-                            # compute the content_delta
-                            arguments_delta = content[
-                                len(
-                                    self.tool_calls[self.current_active_call_id][
-                                        "arguments_render"
-                                    ]
-                                ) :
-                            ]
-                            self.tool_calls[self.current_active_call_id][
-                                "arguments_render"
-                            ] = content
-
-                            if self.current_active_call_id in self.tool_call_mdstreams:
-                                self.tool_call_mdstreams[
-                                    self.current_active_call_id
-                                ].update(content, final=False)
-                            else:
-                                self.config.io.console.print(
-                                    arguments_delta, sep="", end=""
-                                )
+                        # if tool_call_formatter.supports_streaming():
+                        #     content, is_complete = tool_call_formatter.format_input(
+                        #         self.current_active_call_id,
+                        #         self.tool_calls[self.current_active_call_id]["name"],
+                        #         self.tool_calls[self.current_active_call_id][
+                        #             "arguments"
+                        #         ],
+                        #     )
+
+                        #     # compute the content_delta
+                        #     arguments_delta = content[
+                        #         len(
+                        #             self.tool_calls[self.current_active_call_id][
+                        #                 "arguments_render"
+                        #             ]
+                        #         ) :
+                        #     ]
+                        #     self.tool_calls[self.current_active_call_id][
+                        #         "arguments_render"
+                        #     ] = content
+
+                        #     if self.current_active_call_id in self.tool_call_mdstreams:
+                        #         self.tool_call_mdstreams[
+                        #             self.current_active_call_id
+                        #         ].update(content, final=False)
+                        #     else:
+                        #         self.config.io.console.print(
+                        #             arguments_delta, sep="", end=""
+                        #         )
 
                     elif isinstance(stream_data, ResponseOutputItemDoneEvent):
                         if isinstance(stream_data.item, ResponseFunctionToolCall):
@@ -431,33 +440,48 @@ class ConversationTurn(RunTurn):
                                     call_id, tool_name, full_arguments
                                 )
                                 style = tool_call_formatter.get_style()
+                                
+                                # Stage 2: Print tool description/parameters
+                                self.config.io.advance_tool_call_stage()
+                                self.config.io.print_tool_call_all_stages(
+                                    content,
+                                    final=True
+                                )
+                                
+                                # Original streaming/non-streaming handling (commented out)
                                 # if not streaming, only create the mdstream and update the final content
-                                if tool_call_formatter.supports_streaming():
-                                    # process the last tool call stream, stop the live
-                                    if call_id in self.tool_call_mdstreams:
-                                        self.tool_call_mdstreams[call_id].update(
-                                            content,
-                                            final=True,
-                                        )
-                                    if call_id in self.tool_call_mdstreams:
-                                        del self.tool_call_mdstreams[call_id]
-                                else:
-                                    if style == "markdown" and self.config.io.pretty:
-                                        self.tool_call_mdstreams[call_id] = (
-                                            self.get_response_mdstream()
-                                        )
-                                        self.tool_call_mdstreams[call_id].update(
-                                            content, final=True
-                                        )
-                                        if call_id in self.tool_call_mdstreams:
-                                            del self.tool_call_mdstreams[call_id]
-                                    else:
-                                        self.config.io.print_tool_call(content)
+                                # if tool_call_formatter.supports_streaming():
+                                #     # process the last tool call stream, stop the live
+                                #     if call_id in self.tool_call_mdstreams:
+                                #         self.tool_call_mdstreams[call_id].update(
+                                #             content,
+                                #             final=True,
+                                #         )
+                                #     if call_id in self.tool_call_mdstreams:
+                                #         del self.tool_call_mdstreams[call_id]
+                                # else:
+                                #     if style == "markdown" and self.config.io.pretty:
+                                #         self.tool_call_mdstreams[call_id] = (
+                                #             self.get_response_mdstream()
+                                #         )
+                                #         self.tool_call_mdstreams[call_id].update(
+                                #             content, final=True
+                                #         )
+                                #         if call_id in self.tool_call_mdstreams:
+                                #             del self.tool_call_mdstreams[call_id]
+                                #     else:
+                                #         self.config.io.print_tool_call(content)
 
                     elif isinstance(stream_data, ResponseCompletedEvent):
-                        # Print context usage after each model response
-                        # Get usage from the event if available
+                        # Stage 3: Close the Live+Panel display without adding token info
                         usage = stream_data.response.usage if hasattr(stream_data, 'response') and stream_data.response else None
+                        
+                        # Close the Live+Panel display (don't add token info to panel)
+                        if hasattr(self.config.io, '_tool_call_stages') and self.config.io._tool_call_stages:
+                            # Just close the panel without adding token info
+                            self.config.io.print_tool_call_all_stages("", final=True, append=False)
+                        
+                        # Print context usage using original method (outside the panel)
                         self._print_context_usage(usage=usage)
 
                 elif isinstance(event, RunItemStreamEvent):
@@ -467,7 +491,7 @@ class ConversationTurn(RunTurn):
                         if call_id:
                             if call_id in self.tool_calls:
                                 tool_name = self.tool_calls[call_id]["name"]
-                                self.print_split_line()
+                                # self.print_split_line()
                                 output = stream_data.output
                                 if isinstance(output, FunctionCallResult):
                                     self.config.io.print_tool_result(
@@ -510,9 +534,11 @@ class ConversationTurn(RunTurn):
             )
 
             if should_render or final:
-                self.mdstream.update(
-                    processed_content if processed_content else "", final
-                )
+                content_to_update = processed_content if processed_content else ""
+                # When final is True, ensure content ends with newline
+                if final and content_to_update and not content_to_update.endswith('\n'):
+                    content_to_update += '\n'
+                self.mdstream.update(content_to_update, final)
             # If should_render is False, pause mdstream.update temporarily
         else:
             if not self.config.io.pretty:
@@ -534,12 +560,12 @@ class ConversationTurn(RunTurn):
         self.start_time = self._get_timestamp()
         
         # Initialize spinner and inject into session for external access
-        if self.config.io.pretty:
-            spinner = WaitingSpinner(
-                f"Waiting for Agent {self.config.agent_name}..."
-            )
-            # Inject spinner into session state for external access (e.g., stop from outside)
-            self.session.state.spinner = spinner
+        # if self.config.io.pretty:
+        #     spinner = WaitingSpinner(
+        #         f"Waiting for Agent {self.config.agent_name}...", text_color="#79B8FF"
+        #     )
+        #     # Inject spinner into session state for external access (e.g., stop from outside)
+        #     self.session.state.spinner = spinner
 
         # Reset event flags at the beginning of each execution
         self._cleanup_done.clear()
@@ -659,7 +685,7 @@ class ConversationTurn(RunTurn):
 
     def get_response_mdstream(self):
         mdargs = dict(
-            style=self.config.running_color_settings.assistant_output_color,
+            style=self.config.running_color_settings.assistant_output_color, 
             code_theme=self.config.running_color_settings.code_theme,
             inline_code_lexer="text",
         )
@@ -694,7 +720,7 @@ class ConversationTurn(RunTurn):
         from rich.text import Text
 
         # Create styled text with a dim style for subtle display
-        text = Text(message, style="dim cyan")
+        text = Text(message, style="dim #5B9BD5") # rule
         aligned_text = Align.right(text)
 
         self.config.io.console.print(aligned_text)