shotgun-sh 0.2.11.dev1__py3-none-any.whl → 0.2.17.dev1__py3-none-any.whl

shotgun/logging_config.py

@@ -3,11 +3,15 @@
 import logging
 import logging.handlers
 import sys
+from datetime import datetime, timezone
 from pathlib import Path
 
 from shotgun.settings import settings
 from shotgun.utils.env_utils import is_truthy
 
+# Generate a single timestamp for this run to be used across all loggers
+_RUN_TIMESTAMP = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
 
 def get_log_directory() -> Path:
     """Get the log directory path, creating it if necessary.
@@ -66,10 +70,7 @@ def setup_logger(
     logger = logging.getLogger(name)
 
     # Check if we already have a file handler
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If we already have a file handler, just return the logger
     if has_file_handler:
@@ -120,21 +121,16 @@ def setup_logger(
 
     if file_logging_enabled:
         try:
-            # Create file handler with rotation
+            # Create file handler with ISO8601 timestamp for each run
             log_dir = get_log_directory()
-            log_file = log_dir / "shotgun.log"
+            log_file = log_dir / f"shotgun-{_RUN_TIMESTAMP}.log"
 
-            # Use TimedRotatingFileHandler - rotates daily and keeps 7 days of logs
-            file_handler = logging.handlers.TimedRotatingFileHandler(
+            # Use regular FileHandler - each run gets its own isolated log file
+            file_handler = logging.FileHandler(
                 filename=log_file,
-                when="midnight",  # Rotate at midnight
-                interval=1,  # Every 1 day
-                backupCount=7,  # Keep 7 days of logs
                 encoding="utf-8",
             )
 
-            # Also set max file size (10MB) using RotatingFileHandler as fallback
-            # Note: We'll use TimedRotatingFileHandler which handles both time and size
             file_handler.setLevel(getattr(logging, log_level))
 
             # Use standard formatter for file (no colors)
@@ -189,10 +185,7 @@ def get_logger(name: str) -> logging.Logger:
     logger = logging.getLogger(name)
 
     # Check if we have a file handler already
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If no file handler, set up the logger (will add file handler)
     if not has_file_handler:

shotgun/main.py

@@ -56,8 +56,10 @@ logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 # Initialize configuration
 try:
+    import asyncio
+
     config_manager = get_config_manager()
-    config_manager.load()  # Ensure config is loaded at startup
+    asyncio.run(config_manager.load())  # Ensure config is loaded at startup
 except Exception as e:
     logger.debug("Configuration initialization warning: %s", e)
 

shotgun/posthog_telemetry.py

@@ -18,6 +18,9 @@ logger = get_early_logger(__name__)
 # Global PostHog client instance
 _posthog_client = None
 
+# Cache the shotgun instance ID to avoid async calls during event tracking
+_shotgun_instance_id: str | None = None
+
 
 def setup_posthog_observability() -> bool:
     """Set up PostHog analytics for usage tracking.
@@ -25,7 +28,7 @@ def setup_posthog_observability() -> bool:
     Returns:
         True if PostHog was successfully set up, False otherwise
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     try:
         # Check if PostHog is already initialized
@@ -57,29 +60,20 @@ def setup_posthog_observability() -> bool:
         # Store the client for later use
         _posthog_client = posthog
 
-        # Set user context with anonymous shotgun instance ID from config
+        # Cache the shotgun instance ID for later use (avoids async issues)
         try:
-            config_manager = get_config_manager()
-            shotgun_instance_id = config_manager.get_shotgun_instance_id()
-
-            # Identify the user in PostHog
-            posthog.identify(  # type: ignore[attr-defined]
-                distinct_id=shotgun_instance_id,
-                properties={
-                    "version": __version__,
-                    "environment": environment,
-                },
-            )
+            import asyncio
 
-            # Set default properties for all events
-            posthog.disabled = False
-            posthog.personal_api_key = None  # Not needed for event tracking
+            config_manager = get_config_manager()
+            _shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             logger.debug(
-                "PostHog user identified with anonymous ID: %s", shotgun_instance_id
+                "PostHog initialized with shotgun instance ID: %s",
+                _shotgun_instance_id,
             )
         except Exception as e:
-            logger.warning("Failed to set user context: %s", e)
+            logger.warning("Failed to load shotgun instance ID: %s", e)
+            # Continue anyway - we'll try to get it during event tracking
 
         logger.debug(
             "PostHog analytics configured successfully (environment: %s, version: %s)",
@@ -100,16 +94,19 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         event_name: Name of the event to track
         properties: Optional properties to include with the event
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     if _posthog_client is None:
         logger.debug("PostHog not initialized, skipping event: %s", event_name)
         return
 
     try:
-        # Get shotgun instance ID for tracking
-        config_manager = get_config_manager()
-        shotgun_instance_id = config_manager.get_shotgun_instance_id()
+        # Use cached instance ID (loaded during setup)
+        if _shotgun_instance_id is None:
+            logger.warning(
+                "Shotgun instance ID not available, skipping event: %s", event_name
+            )
+            return
 
         # Add version and environment to properties
         if properties is None:
@@ -124,7 +121,7 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
 
         # Track the event using PostHog's capture method
         _posthog_client.capture(
-            distinct_id=shotgun_instance_id, event=event_name, properties=properties
+            distinct_id=_shotgun_instance_id, event=event_name, properties=properties
         )
         logger.debug("Tracked PostHog event: %s", event_name)
     except Exception as e:
@@ -168,10 +165,16 @@ def submit_feedback_survey(feedback: Feedback) -> None:
         logger.debug("PostHog not initialized, skipping feedback survey")
         return
 
+    import asyncio
+
     config_manager = get_config_manager()
-    config = config_manager.load()
+    config = asyncio.run(config_manager.load())
     conversation_manager = ConversationManager()
-    conversation = conversation_manager.load()
+    conversation = None
+    try:
+        conversation = asyncio.run(conversation_manager.load())
+    except Exception as e:
+        logger.debug(f"Failed to load conversation history: {e}")
     last_10_messages = []
     if conversation is not None:
         last_10_messages = conversation.get_agent_messages()[:10]

shotgun/prompts/agents/partials/common_agent_system_prompt.j2

@@ -7,10 +7,11 @@ Your extensive expertise spans, among other things:
 ## KEY RULES
 
 {% if interactive_mode %}
-0. Always ask CLARIFYING QUESTIONS using structured output if the user's request is ambiguous or lacks sufficient detail.
+0. Always ask CLARIFYING QUESTIONS using structured output before doing work.
    - Return your response with the clarifying_questions field populated
-   - Do not make assumptions about what the user wants
+   - Do not make assumptions about what the user wants, get a clear understanding first.
    - Questions should be clear, specific, and answerable
+   - Do not ask too many questions that might overwhelm the user; prioritize the most important ones.
 {% endif %}
 1. Above all, prefer using tools to do the work and NEVER respond with text.
 2. IMPORTANT: Always ask for review and go ahead to move forward after using write_file().

shotgun/sentry_telemetry.py

@@ -1,5 +1,8 @@
 """Sentry observability setup for Shotgun."""
 
+from pathlib import Path
+from typing import Any
+
 from shotgun import __version__
 from shotgun.logging_config import get_early_logger
 from shotgun.settings import settings
@@ -8,6 +11,122 @@ from shotgun.settings import settings
 logger = get_early_logger(__name__)
 
 
+def _scrub_path(path: str) -> str:
+    """Scrub sensitive information from file paths.
+
+    Removes home directory and current working directory prefixes to prevent
+    leaking usernames that might be part of the path.
+
+    Args:
+        path: The file path to scrub
+
+    Returns:
+        The scrubbed path with sensitive prefixes removed
+    """
+    if not path:
+        return path
+
+    try:
+        # Get home and cwd as Path objects for comparison
+        home = Path.home()
+        cwd = Path.cwd()
+
+        # Convert path to Path object
+        path_obj = Path(path)
+
+        # Try to make path relative to cwd first (most common case)
+        try:
+            relative_to_cwd = path_obj.relative_to(cwd)
+            return str(relative_to_cwd)
+        except ValueError:
+            pass
+
+        # Try to replace home directory with ~
+        try:
+            relative_to_home = path_obj.relative_to(home)
+            return f"~/{relative_to_home}"
+        except ValueError:
+            pass
+
+        # If path is absolute but not under cwd or home, just return filename
+        if path_obj.is_absolute():
+            return path_obj.name
+
+        # Return as-is if already relative
+        return path
+
+    except Exception:
+        # If anything goes wrong, return the original path
+        # Better to leak a path than break error reporting
+        return path
+
+
+def _scrub_sensitive_paths(event: dict[str, Any]) -> None:
+    """Scrub sensitive paths from Sentry event data.
+
+    Modifies the event in-place to remove:
+    - Home directory paths (might contain usernames)
+    - Current working directory paths (might contain usernames)
+    - Server name/hostname
+    - Paths in sys.argv
+
+    Args:
+        event: The Sentry event dictionary to scrub
+    """
+    extra = event.get("extra", {})
+    if "sys.argv" in extra:
+        argv = extra["sys.argv"]
+        if isinstance(argv, list):
+            extra["sys.argv"] = [
+                _scrub_path(arg) if isinstance(arg, str) else arg for arg in argv
+            ]
+
+    # Scrub server name if present
+    if "server_name" in event:
+        event["server_name"] = ""
+
+    # Scrub contexts that might contain paths
+    if "contexts" in event:
+        contexts = event["contexts"]
+        # Remove runtime context if it has CWD
+        if "runtime" in contexts:
+            if "cwd" in contexts["runtime"]:
+                del contexts["runtime"]["cwd"]
+            # Scrub sys.argv to remove paths
+            if "sys.argv" in contexts["runtime"]:
+                argv = contexts["runtime"]["sys.argv"]
+                if isinstance(argv, list):
+                    contexts["runtime"]["sys.argv"] = [
+                        _scrub_path(arg) if isinstance(arg, str) else arg
+                        for arg in argv
+                    ]
+
+    # Scrub exception stack traces
+    if "exception" in event and "values" in event["exception"]:
+        for exception in event["exception"]["values"]:
+            if "stacktrace" in exception and "frames" in exception["stacktrace"]:
+                for frame in exception["stacktrace"]["frames"]:
+                    # Scrub file paths
+                    if "abs_path" in frame:
+                        frame["abs_path"] = _scrub_path(frame["abs_path"])
+                    if "filename" in frame:
+                        frame["filename"] = _scrub_path(frame["filename"])
+
+                    # Scrub local variables that might contain paths
+                    if "vars" in frame:
+                        for var_name, var_value in frame["vars"].items():
+                            if isinstance(var_value, str):
+                                frame["vars"][var_name] = _scrub_path(var_value)
+
+    # Scrub breadcrumbs that might contain paths
+    if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
+        for breadcrumb in event["breadcrumbs"]["values"]:
+            if "data" in breadcrumb:
+                for key, value in breadcrumb["data"].items():
+                    if isinstance(value, str):
+                        breadcrumb["data"][key] = _scrub_path(value)
+
+
 def setup_sentry_observability() -> bool:
     """Set up Sentry observability for error tracking.
 
@@ -32,28 +151,67 @@ def setup_sentry_observability() -> bool:
         logger.debug("Using Sentry DSN from settings, proceeding with setup")
 
         # Determine environment based on version
-        # Dev versions contain "dev", "rc", "alpha", or "beta"
+        # Dev versions contain "dev", "rc", "alpha", "beta"
         if any(marker in __version__ for marker in ["dev", "rc", "alpha", "beta"]):
             environment = "development"
         else:
             environment = "production"
 
+        def before_send(event: Any, hint: dict[str, Any]) -> Any:
+            """Filter out user-actionable errors and scrub sensitive paths.
+
+            User-actionable errors (like context size limits) are expected conditions
+            that users need to resolve, not bugs that need tracking.
+
+            Also scrubs sensitive information like usernames from file paths and
+            working directories to protect user privacy.
+            """
+
+            log_record = hint.get("log_record")
+            if log_record:
+                # Scrub pathname using the helper function
+                log_record.pathname = _scrub_path(log_record.pathname)
+
+                # Scrub traceback text if it exists
+                if hasattr(log_record, "exc_text") and isinstance(
+                    log_record.exc_text, str
+                ):
+                    # Replace home directory in traceback text
+                    home = Path.home()
+                    log_record.exc_text = log_record.exc_text.replace(str(home), "~")
+
+            if "exc_info" in hint:
+                _, exc_value, _ = hint["exc_info"]
+                from shotgun.exceptions import ErrorNotPickedUpBySentry
+
+                if isinstance(exc_value, ErrorNotPickedUpBySentry):
+                    # Don't send to Sentry - this is user-actionable, not a bug
+                    return None
+
+            # Scrub sensitive paths from the event
+            _scrub_sensitive_paths(event)
+            return event
+
         # Initialize Sentry
         sentry_sdk.init(
             dsn=dsn,
             release=f"shotgun-sh@{__version__}",
             environment=environment,
             send_default_pii=False,  # Privacy-first: never send PII
+            server_name="",  # Privacy: don't send hostname (may contain username)
             traces_sample_rate=0.1 if environment == "production" else 1.0,
             profiles_sample_rate=0.1 if environment == "production" else 1.0,
+            before_send=before_send,
         )
 
         # Set user context with anonymous shotgun instance ID from config
         try:
+            import asyncio
+
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            shotgun_instance_id = config_manager.get_shotgun_instance_id()
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
             sentry_sdk.set_user({"id": shotgun_instance_id})
             logger.debug("Sentry user context set with anonymous ID")
         except Exception as e:

shotgun/telemetry.py

@@ -50,12 +50,14 @@ def setup_logfire_observability() -> bool:
 
         # Set user context using baggage for all logs and spans
         try:
+            import asyncio
+
             from opentelemetry import baggage, context
 
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            shotgun_instance_id = config_manager.get_shotgun_instance_id()
+            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             # Set shotgun_instance_id as baggage in global context - this will be included in all logs/spans
             ctx = baggage.set_baggage("shotgun_instance_id", shotgun_instance_id)

shotgun/tui/app.py

@@ -5,6 +5,7 @@ from textual.app import App, SystemCommand
 from textual.binding import Binding
 from textual.screen import Screen
 
+from shotgun.agents.agent_manager import AgentManager
 from shotgun.agents.config import ConfigManager, get_config_manager
 from shotgun.agents.models import AgentType
 from shotgun.logging_config import get_logger
@@ -18,7 +19,7 @@ from shotgun.utils.update_checker import (
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
-from .screens.feedback import FeedbackScreen
+from .screens.github_issue import GitHubIssueScreen
 from .screens.model_picker import ModelPickerScreen
 from .screens.pipx_migration import PipxMigrationScreen
 from .screens.provider_config import ProviderConfigScreen
@@ -34,7 +35,7 @@ class ShotgunApp(App[None]):
         "provider_config": ProviderConfigScreen,
         "model_picker": ModelPickerScreen,
         "directory_setup": DirectorySetupScreen,
-        "feedback": FeedbackScreen,
+        "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit the app"),
@@ -95,65 +96,75 @@ class ShotgunApp(App[None]):
                 )
                 return
 
-        # Show welcome screen if no providers are configured OR if user hasn't seen it yet
-        config = self.config_manager.load()
-        if (
-            not self.config_manager.has_any_provider_key()
-            or not config.shown_welcome_screen
-        ):
-            if isinstance(self.screen, WelcomeScreen):
+        # Run async config loading in worker
+        async def _check_config() -> None:
+            # Show welcome screen if no providers are configured OR if user hasn't seen it yet
+            config = await self.config_manager.load()
+            has_any_key = await self.config_manager.has_any_provider_key()
+            if not has_any_key or not config.shown_welcome_screen:
+                if isinstance(self.screen, WelcomeScreen):
+                    return
+
+                self.push_screen(
+                    WelcomeScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
                 return
 
-            self.push_screen(
-                WelcomeScreen(),
-                callback=lambda _arg: self.refresh_startup_screen(),
-            )
-            return
+            if not self.check_local_shotgun_directory_exists():
+                if isinstance(self.screen, DirectorySetupScreen):
+                    return
+
+                self.push_screen(
+                    DirectorySetupScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
+                return
 
-        if not self.check_local_shotgun_directory_exists():
-            if isinstance(self.screen, DirectorySetupScreen):
+            if isinstance(self.screen, ChatScreen):
                 return
 
-            self.push_screen(
-                DirectorySetupScreen(),
-                callback=lambda _arg: self.refresh_startup_screen(),
+            # Create ChatScreen with all dependencies injected from container
+            # Get the default agent mode (RESEARCH)
+            agent_mode = AgentType.RESEARCH
+
+            # Create AgentDeps asynchronously (get_provider_model is now async)
+            from shotgun.tui.dependencies import create_default_tui_deps
+
+            agent_deps = await create_default_tui_deps()
+
+            # Create AgentManager with async initialization
+            agent_manager = AgentManager(deps=agent_deps, initial_type=agent_mode)
+
+            # Create ProcessingStateManager - we'll pass the screen after creation
+            # For now, create with None and the ChatScreen will set itself
+            chat_screen = ChatScreen(
+                agent_manager=agent_manager,
+                conversation_manager=self.container.conversation_manager(),
+                conversation_service=self.container.conversation_service(),
+                widget_coordinator=self.container.widget_coordinator_factory(
+                    screen=None
+                ),
+                processing_state=self.container.processing_state_factory(
+                    screen=None,  # Will be set after ChatScreen is created
+                    telemetry_context={"agent_mode": agent_mode.value},
+                ),
+                command_handler=self.container.command_handler(),
+                placeholder_hints=self.container.placeholder_hints(),
+                codebase_sdk=self.container.codebase_sdk(),
+                deps=agent_deps,
+                continue_session=self.continue_session,
+                force_reindex=self.force_reindex,
             )
-            return
-
-        if isinstance(self.screen, ChatScreen):
-            return
-
-        # Create ChatScreen with all dependencies injected from container
-        # Get the default agent mode (RESEARCH)
-        agent_mode = AgentType.RESEARCH
-
-        # Create AgentManager with the correct mode
-        agent_manager = self.container.agent_manager_factory(initial_type=agent_mode)
-
-        # Create ProcessingStateManager - we'll pass the screen after creation
-        # For now, create with None and the ChatScreen will set itself
-        chat_screen = ChatScreen(
-            agent_manager=agent_manager,
-            conversation_manager=self.container.conversation_manager(),
-            conversation_service=self.container.conversation_service(),
-            widget_coordinator=self.container.widget_coordinator_factory(screen=None),
-            processing_state=self.container.processing_state_factory(
-                screen=None,  # Will be set after ChatScreen is created
-                telemetry_context={"agent_mode": agent_mode.value},
-            ),
-            command_handler=self.container.command_handler(),
-            placeholder_hints=self.container.placeholder_hints(),
-            codebase_sdk=self.container.codebase_sdk(),
-            deps=self.container.agent_deps(),
-            continue_session=self.continue_session,
-            force_reindex=self.force_reindex,
-        )
 
-        # Update the ProcessingStateManager and WidgetCoordinator with the actual ChatScreen instance
-        chat_screen.processing_state.screen = chat_screen
-        chat_screen.widget_coordinator.screen = chat_screen
+            # Update the ProcessingStateManager and WidgetCoordinator with the actual ChatScreen instance
+            chat_screen.processing_state.screen = chat_screen
+            chat_screen.widget_coordinator.screen = chat_screen
 
-        self.push_screen(chat_screen)
+            self.push_screen(chat_screen)
+
+        # Run the async config check in a worker
+        self.run_worker(_check_config(), exclusive=False)
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -170,20 +181,15 @@ class ShotgunApp(App[None]):
     def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:
         return [
             SystemCommand(
-                "Feedback", "Send us feedback or report a bug", self.action_feedback
+                "New Issue",
+                "Report a bug or request a feature on GitHub",
+                self.action_new_issue,
             )
-        ]  # we don't want any system commands
-
-    def action_feedback(self) -> None:
-        """Open feedback screen and submit feedback."""
-        from shotgun.posthog_telemetry import Feedback, submit_feedback_survey
-
-        def handle_feedback(feedback: Feedback | None) -> None:
-            if feedback is not None:
-                submit_feedback_survey(feedback)
-                self.notify("Feedback sent. Thank you!")
+        ]
 
-        self.push_screen(FeedbackScreen(), callback=handle_feedback)
+    def action_new_issue(self) -> None:
+        """Open GitHub issue screen to guide users to create an issue."""
+        self.push_screen(GitHubIssueScreen())
 
 
 def run(

shotgun/tui/components/context_indicator.py

@@ -1,6 +1,7 @@
 """Context window indicator component for showing model usage."""
 
 from textual.reactive import reactive
+from textual.timer import Timer
 from textual.widgets import Static
 
 from shotgun.agents.config.models import MODEL_SPECS, ModelName
@@ -20,6 +21,10 @@ class ContextIndicator(Static):
 
     context_analysis: reactive[ContextAnalysis | None] = reactive(None)
     model_name: reactive[ModelName | None] = reactive(None)
+    is_streaming: reactive[bool] = reactive(False)
+
+    _animation_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    _animation_index = 0
 
     def __init__(
         self,
@@ -29,6 +34,7 @@ class ContextIndicator(Static):
         classes: str | None = None,
     ) -> None:
         super().__init__(name=name, id=id, classes=classes)
+        self._animation_timer: Timer | None = None
 
     def update_context(
         self, analysis: ContextAnalysis | None, model: ModelName | None
@@ -43,6 +49,38 @@ class ContextIndicator(Static):
         self.model_name = model
         self._refresh_display()
 
+    def set_streaming(self, streaming: bool) -> None:
+        """Enable or disable streaming animation.
+
+        Args:
+            streaming: Whether to show streaming animation
+        """
+        self.is_streaming = streaming
+        if streaming:
+            self._start_animation()
+        else:
+            self._stop_animation()
+
+    def _start_animation(self) -> None:
+        """Start the pulsing animation."""
+        if self._animation_timer is None:
+            self._animation_timer = self.set_interval(0.1, self._animate_frame)
+
+    def _stop_animation(self) -> None:
+        """Stop the pulsing animation."""
+        if self._animation_timer is not None:
+            self._animation_timer.stop()
+            self._animation_timer = None
+        self._animation_index = 0
+        self._refresh_display()
+
+    def _animate_frame(self) -> None:
+        """Advance the animation frame."""
+        self._animation_index = (self._animation_index + 1) % len(
+            self._animation_frames
+        )
+        self._refresh_display()
+
     def _get_percentage_color(self, percentage: float) -> str:
         """Get color for percentage based on threshold.
 
@@ -112,6 +150,11 @@ class ContextIndicator(Static):
             f"[{color}]{percentage}% ({current_tokens}/{max_tokens})[/]",
         ]
 
+        # Add streaming animation indicator if streaming
+        if self.is_streaming:
+            animation_char = self._animation_frames[self._animation_index]
+            parts.append(f"[bold cyan]{animation_char}[/]")
+
         # Add model name if available
         if self.model_name:
             model_spec = MODEL_SPECS.get(self.model_name)