shotgun-sh 0.2.29.dev2__py3-none-any.whl → 0.6.1.dev1__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -19,8 +19,10 @@ from tenacity import (
 if TYPE_CHECKING:
     from shotgun.agents.conversation import ConversationState
 
+import base64
+
 from pydantic_ai import (
-    Agent,
+    BinaryContent,
     RunContext,
     UsageLimits,
 )
@@ -38,13 +40,16 @@ from pydantic_ai.messages import (
     PartDeltaEvent,
     PartStartEvent,
     SystemPromptPart,
+    TextPartDelta,
     ToolCallPart,
     ToolCallPartDelta,
+    UserContent,
     UserPromptPart,
 )
 from textual.message import Message
 from textual.widget import Widget
 
+from shotgun.agents.cancellation import CancellableStreamIterator
 from shotgun.agents.common import add_system_prompt_message, add_system_status_message
 from shotgun.agents.config.models import (
     KeyProvider,
@@ -61,19 +66,25 @@ from shotgun.agents.context_analyzer import (
 from shotgun.agents.models import (
     AgentResponse,
     AgentType,
+    AnyAgent,
     FileOperation,
     FileOperationTracker,
+    RouterAgent,
+    ShotgunAgent,
 )
+from shotgun.attachments import FileAttachment
 from shotgun.posthog_telemetry import track_event
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.utils.source_detection import detect_source
 
 from .conversation.history.compaction import apply_persistent_compaction
 from .export import create_export_agent
-from .messages import AgentSystemPrompt
+from .messages import AgentSystemPrompt, InternalPromptPart
 from .models import AgentDeps, AgentRuntimeOptions
 from .plan import create_plan_agent
 from .research import create_research_agent
+from .router import create_router_agent
+from .router.models import RouterDeps, RouterMode
 from .specify import create_specify_agent
 from .tasks import create_tasks_agent
 
@@ -166,6 +177,29 @@ class ClarifyingQuestionsMessage(Message):
         self.response_text = response_text
 
 
+class FileRequestPendingMessage(Message):
+    """Event posted when agent requests files to be loaded.
+
+    This triggers the TUI to load the requested files and resume
+    the agent with the file contents in the next prompt.
+    """
+
+    def __init__(
+        self,
+        file_paths: list[str],
+        response_text: str,
+    ) -> None:
+        """Initialize the file request pending message.
+
+        Args:
+            file_paths: List of file paths the agent wants to read
+            response_text: The agent's response text before requesting files
+        """
+        super().__init__()
+        self.file_paths = file_paths
+        self.response_text = response_text
+
+
 class CompactionStartedMessage(Message):
     """Event posted when conversation compaction starts."""
 
@@ -174,6 +208,67 @@ class CompactionCompletedMessage(Message):
     """Event posted when conversation compaction completes."""
 
 
+class ToolExecutionStartedMessage(Message):
+    """Event posted when a tool starts executing.
+
+    This allows the UI to update the spinner text to provide feedback
+    during long-running tool executions.
+    """
+
+    def __init__(self, spinner_text: str = "Processing...") -> None:
+        """Initialize the tool execution started message.
+
+        Args:
+            spinner_text: The spinner message to display
+        """
+        super().__init__()
+        self.spinner_text = spinner_text
+
+
+class ToolStreamingProgressMessage(Message):
+    """Event posted during tool call streaming to show progress.
+
+    This provides visual feedback while tool arguments are streaming,
+    especially useful for long-running writes like file content.
+    """
+
+    def __init__(self, streamed_tokens: int, spinner_text: str) -> None:
+        """Initialize the tool streaming progress message.
+
+        Args:
+            streamed_tokens: Approximate number of tokens streamed so far
+            spinner_text: The current spinner message to preserve
+        """
+        super().__init__()
+        self.streamed_tokens = streamed_tokens
+        self.spinner_text = spinner_text
+
+
+# Fun spinner messages to show during tool execution
+SPINNER_MESSAGES = [
+    "Pontificating...",
+    "Ruminating...",
+    "Cogitating...",
+    "Deliberating...",
+    "Contemplating...",
+    "Reticulating splines...",
+    "Consulting the oracle...",
+    "Gathering thoughts...",
+    "Processing neurons...",
+    "Summoning wisdom...",
+    "Brewing ideas...",
+    "Polishing pixels...",
+    "Herding electrons...",
+    "Warming up the flux capacitor...",
+    "Consulting ancient tomes...",
+    "Channeling the muses...",
+    "Percolating possibilities...",
+    "Untangling complexity...",
+    "Shuffling priorities...",
+    "Aligning the stars...",
+]
+
+
 class AgentStreamingStarted(Message):
     """Event posted when agent starts streaming responses."""
 
@@ -210,6 +305,11 @@ class _PartialStreamState:
 
     messages: list[ModelRequest | ModelResponse] = field(default_factory=list)
     current_response: ModelResponse | None = None
+    # Token counting for tool call streaming progress
+    streamed_tokens: int = 0
+    current_spinner_text: str = "Processing..."
+    # Track last reported tokens to throttle UI updates
+    last_reported_tokens: int = 0
 
 
 class AgentManager(Widget):
@@ -245,16 +345,18 @@ class AgentManager(Widget):
         )
 
         # Lazy initialization - agents created on first access
-        self._research_agent: Agent[AgentDeps, AgentResponse] | None = None
+        self._research_agent: ShotgunAgent | None = None
         self._research_deps: AgentDeps | None = None
-        self._plan_agent: Agent[AgentDeps, AgentResponse] | None = None
+        self._plan_agent: ShotgunAgent | None = None
         self._plan_deps: AgentDeps | None = None
-        self._tasks_agent: Agent[AgentDeps, AgentResponse] | None = None
+        self._tasks_agent: ShotgunAgent | None = None
         self._tasks_deps: AgentDeps | None = None
-        self._specify_agent: Agent[AgentDeps, AgentResponse] | None = None
+        self._specify_agent: ShotgunAgent | None = None
         self._specify_deps: AgentDeps | None = None
-        self._export_agent: Agent[AgentDeps, AgentResponse] | None = None
+        self._export_agent: ShotgunAgent | None = None
         self._export_deps: AgentDeps | None = None
+        self._router_agent: RouterAgent | None = None
+        self._router_deps: RouterDeps | None = None
         self._agents_initialized = False
 
         # Track current active agent
@@ -270,6 +372,10 @@ class AgentManager(Widget):
         self._qa_questions: list[str] | None = None
         self._qa_mode_active: bool = False
 
+        # File request state for structured output file loading
+        self._file_request_pending: bool = False
+        self._pending_file_requests: list[str] = []
+
     async def _ensure_agents_initialized(self) -> None:
         """Ensure all agents are initialized (lazy initialization)."""
         if self._agents_initialized:
@@ -291,10 +397,13 @@ class AgentManager(Widget):
         self._export_agent, self._export_deps = await create_export_agent(
             agent_runtime_options=self._agent_runtime_options
         )
+        self._router_agent, self._router_deps = await create_router_agent(
+            agent_runtime_options=self._agent_runtime_options
+        )
         self._agents_initialized = True
 
     @property
-    def research_agent(self) -> Agent[AgentDeps, AgentResponse]:
+    def research_agent(self) -> ShotgunAgent:
         """Get research agent (must call _ensure_agents_initialized first)."""
         if self._research_agent is None:
             raise RuntimeError(
@@ -312,7 +421,7 @@ class AgentManager(Widget):
         return self._research_deps
 
     @property
-    def plan_agent(self) -> Agent[AgentDeps, AgentResponse]:
+    def plan_agent(self) -> ShotgunAgent:
         """Get plan agent (must call _ensure_agents_initialized first)."""
         if self._plan_agent is None:
             raise RuntimeError(
@@ -330,7 +439,7 @@ class AgentManager(Widget):
         return self._plan_deps
 
     @property
-    def tasks_agent(self) -> Agent[AgentDeps, AgentResponse]:
+    def tasks_agent(self) -> ShotgunAgent:
         """Get tasks agent (must call _ensure_agents_initialized first)."""
         if self._tasks_agent is None:
             raise RuntimeError(
@@ -348,7 +457,7 @@ class AgentManager(Widget):
         return self._tasks_deps
 
     @property
-    def specify_agent(self) -> Agent[AgentDeps, AgentResponse]:
+    def specify_agent(self) -> ShotgunAgent:
         """Get specify agent (must call _ensure_agents_initialized first)."""
         if self._specify_agent is None:
             raise RuntimeError(
@@ -366,7 +475,7 @@ class AgentManager(Widget):
         return self._specify_deps
 
     @property
-    def export_agent(self) -> Agent[AgentDeps, AgentResponse]:
+    def export_agent(self) -> ShotgunAgent:
         """Get export agent (must call _ensure_agents_initialized first)."""
         if self._export_agent is None:
             raise RuntimeError(
@@ -384,29 +493,114 @@ class AgentManager(Widget):
         return self._export_deps
 
     @property
-    def current_agent(self) -> Agent[AgentDeps, AgentResponse]:
+    def router_agent(self) -> RouterAgent:
+        """Get router agent (must call _ensure_agents_initialized first)."""
+        if self._router_agent is None:
+            raise RuntimeError(
+                "Agents not initialized. Call _ensure_agents_initialized() first."
+            )
+        return self._router_agent
+
+    @property
+    def router_deps(self) -> RouterDeps:
+        """Get router deps (must call _ensure_agents_initialized first)."""
+        if self._router_deps is None:
+            raise RuntimeError(
+                "Agents not initialized. Call _ensure_agents_initialized() first."
+            )
+        return self._router_deps
+
+    @property
+    def current_agent(self) -> AnyAgent:
         """Get the currently active agent.
 
         Returns:
-            The currently selected agent instance.
+            The currently selected agent instance (ShotgunAgent or RouterAgent).
         """
         return self._get_agent(self._current_agent_type)
 
-    def _get_agent(self, agent_type: AgentType) -> Agent[AgentDeps, AgentResponse]:
+    @property
+    def file_request_pending(self) -> bool:
+        """Check if there's a pending file request."""
+        return self._file_request_pending
+
+    @property
+    def pending_file_requests(self) -> list[str]:
+        """Get the list of pending file requests."""
+        return self._pending_file_requests
+
+    def process_file_requests(self) -> list[tuple[str, BinaryContent]]:
+        """Process pending file requests and return loaded content.
+
+        This method is called by the TUI after FileRequestPendingMessage is received.
+        It loads the requested files as BinaryContent and clears the pending state.
+
+        Returns:
+            List of (file_path, BinaryContent) tuples for files that were successfully loaded.
+        """
+        if not self._file_request_pending:
+            return []
+
+        # MIME type mapping for supported file types
+        mime_types: dict[str, str] = {
+            ".pdf": "application/pdf",
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+        }
+
+        loaded_files: list[tuple[str, BinaryContent]] = []
+        for file_path_str in self._pending_file_requests:
+            try:
+                path = Path(file_path_str).expanduser().resolve()
+                if not path.exists():
+                    logger.warning(f"Requested file not found: {path}")
+                    continue
+
+                # Get MIME type
+                suffix = path.suffix.lower()
+                mime_type = mime_types.get(suffix)
+                if mime_type is None:
+                    logger.warning(f"Unsupported file type: {suffix} for {path}")
+                    continue
+
+                # Read file and create BinaryContent
+                data = path.read_bytes()
+                loaded_files.append(
+                    (str(path), BinaryContent(data=data, media_type=mime_type))
+                )
+                logger.debug(f"Loaded file: {path} ({len(data)} bytes)")
+
+            except Exception as e:
+                logger.error(f"Error loading file {file_path_str}: {e}")
+
+        # Clear pending state
+        self._file_request_pending = False
+        self._pending_file_requests = []
+
+        logger.info(
+            f"Loaded {len(loaded_files)} of {len(self._pending_file_requests)} requested files"
+        )
+        return loaded_files
+
+    def _get_agent(self, agent_type: AgentType) -> AnyAgent:
         """Get agent by type.
 
         Args:
             agent_type: The type of agent to retrieve.
 
         Returns:
-            The requested agent instance.
+            The requested agent instance (ShotgunAgent or RouterAgent).
         """
-        agent_map = {
+        agent_map: dict[AgentType, AnyAgent] = {
             AgentType.RESEARCH: self.research_agent,
             AgentType.PLAN: self.plan_agent,
             AgentType.TASKS: self.tasks_agent,
             AgentType.SPECIFY: self.specify_agent,
             AgentType.EXPORT: self.export_agent,
+            AgentType.ROUTER: self.router_agent,
         }
         return agent_map[agent_type]
 
@@ -419,12 +613,13 @@ class AgentManager(Widget):
         Returns:
             The agent-specific dependencies.
         """
-        deps_map = {
+        deps_map: dict[AgentType, AgentDeps] = {
             AgentType.RESEARCH: self.research_deps,
             AgentType.PLAN: self.plan_deps,
             AgentType.TASKS: self.tasks_deps,
             AgentType.SPECIFY: self.specify_deps,
             AgentType.EXPORT: self.export_deps,
+            AgentType.ROUTER: self.router_deps,
         }
         return deps_map[agent_type]
 
@@ -433,6 +628,10 @@ class AgentManager(Widget):
 
         This preserves the agent's system_prompt_fn while using shared runtime state.
 
+        For Router agent, returns the shared deps directly (not a copy) because
+        Router state (pending_approval, current_plan, etc.) must be shared with
+        the TUI for features like plan approval widgets.
+
         Args:
             agent_type: The type of agent to create merged deps for.
 
@@ -445,8 +644,14 @@ class AgentManager(Widget):
         if self.deps is None:
             raise ValueError("Shared deps is None - this should not happen")
 
-        # Create new deps with shared runtime state but agent's system_prompt_fn
-        # Use a copy of the shared deps and update the system_prompt_fn
+        # For Router, use shared deps directly so state mutations are visible to TUI
+        # (e.g., pending_approval, current_plan need to be seen by ChatScreen)
+        if agent_type == AgentType.ROUTER:
+            # Update system_prompt_fn on shared deps in place
+            self.deps.system_prompt_fn = agent_deps.system_prompt_fn
+            return self.deps
+
+        # For other agents, create a copy with agent-specific system_prompt_fn
         merged_deps = self.deps.model_copy(
             update={"system_prompt_fn": agent_deps.system_prompt_fn}
         )
@@ -478,8 +683,8 @@ class AgentManager(Widget):
     )
     async def _run_agent_with_retry(
         self,
-        agent: Agent[AgentDeps, AgentResponse],
-        prompt: str | None,
+        agent: AnyAgent,
+        prompt: str | Sequence[UserContent] | None,
         deps: AgentDeps,
         usage_limits: UsageLimits | None,
         message_history: list[ModelMessage],
@@ -489,9 +694,10 @@ class AgentManager(Widget):
         """Run agent with automatic retry on transient errors.
 
         Args:
-            agent: The agent to run.
-            prompt: Optional prompt to send to the agent.
-            deps: Agent dependencies.
+            agent: The agent to run (ShotgunAgent or RouterAgent).
+            prompt: Optional prompt to send to the agent. Can be a string,
+                a sequence of UserContent (for multimodal), or None.
+            deps: Agent dependencies (AgentDeps or RouterDeps).
             usage_limits: Optional usage limits.
             message_history: Message history to provide to agent.
             event_stream_handler: Event handler for streaming.
@@ -502,8 +708,16 @@ class AgentManager(Widget):
 
         Raises:
             Various exceptions if all retries fail.
+
+        Note:
+            Type safety for agent/deps pairing is maintained by AgentManager's
+            _get_agent_deps which ensures the correct deps type is used for each
+            agent type. The cast is needed because Agent is contravariant in deps.
         """
-        return await agent.run(
+        # Cast needed because Agent is contravariant in deps type parameter.
+        # The agent/deps pairing is ensured by _get_agent_deps returning the
+        # correct deps type for each agent type.
+        return await cast(ShotgunAgent, agent).run(
             prompt,
             deps=deps,
             usage_limits=usage_limits,
@@ -516,6 +730,8 @@ class AgentManager(Widget):
         self,
         prompt: str | None = None,
         *,
+        attachment: FileAttachment | None = None,
+        file_contents: list[tuple[str, BinaryContent]] | None = None,
         deps: AgentDeps | None = None,
         usage_limits: UsageLimits | None = None,
         **kwargs: Any,
@@ -527,6 +743,9 @@ class AgentManager(Widget):
 
         Args:
             prompt: Optional prompt to send to the agent.
+            attachment: Optional file attachment to include as multimodal content.
+            file_contents: Optional list of (file_path, BinaryContent) tuples to include
+                          as multimodal content. Used when resuming after file_requests.
             deps: Optional dependencies override (defaults to manager's deps).
             usage_limits: Optional usage limits for the agent run.
             **kwargs: Additional keyword arguments to pass to the agent.
@@ -560,6 +779,11 @@ class AgentManager(Widget):
 
         deps.agent_mode = self._current_agent_type
 
+        # For router agent, set up the parent stream handler so sub-agents can stream
+        if self._current_agent_type == AgentType.ROUTER:
+            if isinstance(deps, RouterDeps):
+                deps.parent_stream_handler = self._handle_event_stream  # type: ignore[assignment]
+
         # Filter out system prompts from other agent types
         from pydantic_ai.messages import ModelRequestPart
 
@@ -634,7 +858,7 @@ class AgentManager(Widget):
                             "**Options:**\n"
                             "- Get a [Shotgun Account](https://shotgun.sh) - streaming works out of the box\n"
                             "- Complete [Biometric Verification](https://platform.openai.com/settings/organization/general) with OpenAI, then:\n"
-                            "  1. Press `Ctrl+P` → Open Provider Setup\n"
+                            "  1. Press `/` → Open Provider Setup\n"
                             "  2. Select OpenAI → Clear key\n"
                             "  3. Re-add your OpenAI API key\n\n"
                             "Continuing without streaming (responses will appear all at once)."
@@ -650,13 +874,46 @@ class AgentManager(Widget):
             {
                 "has_prompt": prompt is not None,
                 "model_name": model_name,
+                "has_attachment": attachment is not None,
             },
         )
 
+        # Construct multimodal prompt if attachment or file_contents is provided
+        user_prompt: str | Sequence[UserContent] | None = prompt
+
+        if file_contents:
+            # File contents from file_requests - construct multimodal prompt with files
+            content_parts: list[UserContent] = [
+                prompt or "Here are the files you requested:"
+            ]
+            for file_path, binary in file_contents:
+                content_parts.append(f"\n\n--- File: {file_path} ---")
+                content_parts.append(binary)
+            user_prompt = content_parts
+            logger.debug(
+                "Constructed multimodal prompt with requested files",
+                extra={"num_files": len(file_contents)},
+            )
+        elif attachment and attachment.content_base64:
+            # Use BinaryContent which is supported by all providers (OpenAI, Anthropic, Google)
+            binary_data = base64.b64decode(attachment.content_base64)
+            binary_content = BinaryContent(
+                data=binary_data,
+                media_type=attachment.mime_type,
+            )
+            user_prompt = [prompt or "", binary_content]
+            logger.debug(
+                "Constructed multimodal prompt with attachment",
+                extra={
+                    "attachment_type": attachment.file_type.value,
+                    "attachment_size": attachment.file_size_bytes,
+                },
+            )
+
         try:
             result: AgentRunResult[AgentResponse] = await self._run_agent_with_retry(
                 agent=self.current_agent,
-                prompt=prompt,
+                prompt=user_prompt,
                 deps=deps,
                 usage_limits=usage_limits,
                 message_history=message_history,
@@ -742,17 +999,38 @@ class AgentManager(Widget):
         )
 
         # Deduplicate: skip user prompts that are already in original_messages
+        # Note: We compare content only, not timestamps, since UserPromptPart
+        # has a timestamp field that differs between instances
+        def get_user_prompt_text(
+            request: ModelRequest,
+        ) -> str | None:
+            """Extract just the text content from a ModelRequest for deduplication.
+
+            When content is multimodal (list with text + binary), extract just the text.
+            This ensures text-only and multimodal versions of the same prompt match.
+            """
+            for part in request.parts:
+                if isinstance(part, UserPromptPart):
+                    content = part.content
+                    if isinstance(content, str):
+                        return content
+                    elif isinstance(content, list):
+                        # Multimodal content - extract text strings only
+                        text_parts = [item for item in content if isinstance(item, str)]
+                        return text_parts[0] if text_parts else None
+            return None
+
         deduplicated_new_messages = []
         for msg in new_messages:
             # Check if this is a user prompt that's already in original_messages
             if isinstance(msg, ModelRequest) and any(
                 isinstance(part, UserPromptPart) for part in msg.parts
             ):
+                msg_text = get_user_prompt_text(msg)
                 # Check if an identical user prompt is already in original_messages
                 already_exists = any(
                     isinstance(existing, ModelRequest)
-                    and any(isinstance(p, UserPromptPart) for p in existing.parts)
-                    and existing.parts == msg.parts
+                    and get_user_prompt_text(existing) == msg_text
                     for existing in original_messages[
                         -5:
                     ]  # Check last 5 messages for efficiency
@@ -762,6 +1040,13 @@ class AgentManager(Widget):
 
             deduplicated_new_messages.append(msg)
 
+        # Mark file resume prompts as internal (hidden from UI)
+        # When file_contents is provided, the prompt is system-generated, not user input
+        if file_contents:
+            deduplicated_new_messages = self._mark_as_internal_prompts(
+                deduplicated_new_messages
+            )
+
         self.ui_message_history = original_messages + deduplicated_new_messages
 
         # Get file operations early so we can use them for contextual messages
@@ -776,6 +1061,48 @@ class AgentManager(Widget):
             },
         )
 
+        # Check if there are file requests (takes priority over clarifying questions)
+        # But ignore file_requests if we just provided file_contents (prevents infinite loops)
+        if agent_response.file_requests and not file_contents:
+            logger.info(
+                f"Agent requested {len(agent_response.file_requests)} files to be loaded"
+            )
+
+            # Set pending state
+            self._file_request_pending = True
+            self._pending_file_requests = agent_response.file_requests
+
+            # Add agent's response as hint if present
+            if agent_response.response:
+                self.ui_message_history.append(
+                    HintMessage(message=agent_response.response)
+                )
+
+            # Add file loading indicator
+            files_list = "\n".join(f"- `{p}`" for p in agent_response.file_requests)
+            self.ui_message_history.append(
+                HintMessage(message=f"📁 Loading requested files:\n{files_list}")
+            )
+
+            # Post UI update with hint messages
+            self._post_messages_updated([])
+
+            # Post event to TUI to load files and resume
+            self.post_message(
+                FileRequestPendingMessage(
+                    file_paths=agent_response.file_requests,
+                    response_text=agent_response.response,
+                )
+            )
+
+            return result
+        elif agent_response.file_requests and file_contents:
+            # We just provided files, ignore any new file_requests to prevent loops
+            logger.debug(
+                "Ignoring file_requests (files were just provided): %s",
+                agent_response.file_requests,
+            )
+
         # Check if there are clarifying questions
         if agent_response.clarifying_questions:
             logger.info(
@@ -799,11 +1126,16 @@ class AgentManager(Widget):
                 self.ui_message_history.append(
                     HintMessage(message=f"💡 {agent_response.clarifying_questions[0]}")
                 )
+                # Add plan hint for Drafting mode (Planning mode uses PlanPanelWidget)
+                self._maybe_add_plan_hint_drafting_mode(deps)
             else:
                 # Multiple questions (2+) - enter Q&A mode
                 self._qa_questions = agent_response.clarifying_questions
                 self._qa_mode_active = True
 
+                # In Drafting mode, show plan BEFORE Q&A questions (without "Shall I continue?")
+                self._maybe_add_plan_hint_drafting_mode(deps, in_qa_mode=True)
+
                 # Show intro with list, then first question
                 questions_list_with_intro = (
                     f"I have {len(agent_response.clarifying_questions)} questions:\n\n"
@@ -865,6 +1197,9 @@ class AgentManager(Widget):
                         HintMessage(message="✅ Task completed")
                     )
 
+            # Add plan hint for Drafting mode (Planning mode uses PlanPanelWidget)
+            self._maybe_add_plan_hint_drafting_mode(deps)
+
             # Post UI update immediately so user sees the response without delay
             # (file operations will be posted after compaction to avoid duplicates)
             logger.debug("Posting immediate UI update with hint message")
@@ -963,6 +1298,11 @@ class AgentManager(Widget):
         else:
             partial_parts = []
 
+        # Wrap stream with cancellable iterator for responsive ESC handling
+        deps = _ctx.deps
+        if deps.cancellation_event:
+            stream = CancellableStreamIterator(stream, deps.cancellation_event)
+
         async for event in stream:
             try:
                 if isinstance(event, PartStartEvent):
@@ -992,6 +1332,44 @@ class AgentManager(Widget):
                         )
                         continue
 
+                    # Count tokens from the delta for progress indication
+                    delta_len = 0
+                    is_tool_call_delta = False
+                    if isinstance(event.delta, ToolCallPartDelta):
+                        is_tool_call_delta = True
+                        # args_delta can be str or dict depending on provider
+                        args_delta = event.delta.args_delta
+                        if isinstance(args_delta, str):
+                            delta_len = len(args_delta)
+                        elif isinstance(args_delta, dict):
+                            # For dict deltas, estimate from JSON representation
+                            delta_len = len(json.dumps(args_delta))
+                        # Pick a spinner message when tool streaming starts
+                        if state.current_spinner_text == "Processing...":
+                            import random
+
+                            state.current_spinner_text = random.choice(  # noqa: S311
+                                SPINNER_MESSAGES
+                            )
+                    elif isinstance(event.delta, TextPartDelta):
+                        delta_len = len(event.delta.content_delta)
+
+                    if delta_len > 0:
+                        # Approximate tokens: len / 4 is a rough estimate
+                        state.streamed_tokens += delta_len // 4 + 1
+                        # Send progress update for tool call streaming
+                        # Throttle updates to every ~75 tokens to avoid flooding UI
+                        if is_tool_call_delta and (
+                            state.streamed_tokens - state.last_reported_tokens >= 75
+                        ):
+                            state.last_reported_tokens = state.streamed_tokens
+                            self.post_message(
+                                ToolStreamingProgressMessage(
+                                    state.streamed_tokens,
+                                    state.current_spinner_text,
+                                )
+                            )
+
                     try:
                         updated_part = event.delta.apply(
                             cast(ModelResponsePart, partial_parts[index])
@@ -1087,6 +1465,17 @@ class AgentManager(Widget):
                     if partial_message is not None:
                         state.current_response = partial_message
                         self._post_partial_message(False)
+
+                    # Notify UI that a tool is about to execute
+                    # This updates the spinner with a fun message during tool execution
+                    # Pick a random spinner message and store it for progress updates
+                    import random
+
+                    spinner_text = random.choice(SPINNER_MESSAGES)  # noqa: S311
+                    state.current_spinner_text = spinner_text
+                    state.streamed_tokens = 0  # Reset token count for new tool
+                    self.post_message(ToolExecutionStartedMessage(spinner_text))
+
                 elif isinstance(event, FunctionToolResultEvent):
                     # Track tool completion event
 
@@ -1191,6 +1580,47 @@ class AgentManager(Widget):
                 # Common path is a file, show parent directory
                 return f"📁 Modified {num_files} files in: `{path_obj.parent}`"
 
+    def _maybe_add_plan_hint_drafting_mode(
+        self, deps: AgentDeps, in_qa_mode: bool = False
+    ) -> None:
+        """Add execution plan hint for router agent in Drafting mode only.
+
+        In Drafting mode, there's no PlanPanelWidget, so we show the plan
+        in the chat history with a "Shall I continue?" prompt (unless in Q&A mode).
+
+        In Planning mode, the PlanPanelWidget handles plan display.
+
+        Args:
+            deps: Agent dependencies (may be RouterDeps for router agent)
+            in_qa_mode: If True, skip the "Shall I continue?" prompt since user
+                       needs to answer Q&A questions first.
+        """
+        if self._current_agent_type != AgentType.ROUTER:
+            return
+
+        if not isinstance(deps, RouterDeps):
+            return
+
+        # Only show plan hints in Drafting mode
+        # Planning mode uses PlanPanelWidget instead
+        if deps.router_mode != RouterMode.DRAFTING:
+            return
+
+        if deps.current_plan is None:
+            return
+
+        plan_display = deps.current_plan.format_for_display()
+
+        # In drafting mode, if plan is not complete and NOT in Q&A mode,
+        # prompt user to continue
+        if not deps.current_plan.is_complete() and not in_qa_mode:
+            plan_display += "\n\n**Shall I continue?**"
+
+        logger.debug("Adding plan hint to UI history (Drafting mode)")
+        self.ui_message_history.append(
+            HintMessage(message=f"**Current Plan**\n\n{plan_display}")
+        )
+
     def _post_messages_updated(
         self, file_operations: list[FileOperation] | None = None
     ) -> None:
@@ -1203,6 +1633,43 @@ class AgentManager(Widget):
             )
         )
 
+    def _mark_as_internal_prompts(
+        self,
+        messages: list[ModelRequest | ModelResponse | HintMessage],
+    ) -> list[ModelRequest | ModelResponse | HintMessage]:
+        """Mark UserPromptPart as InternalPromptPart for system-generated prompts.
+
+        Used when file_contents is provided - the resume prompt is system-generated,
+        not actual user input, and should be hidden from the UI.
+
+        Args:
+            messages: List of messages that may contain user prompts to mark as internal
+
+        Returns:
+            List of messages with UserPromptPart converted to InternalPromptPart
+        """
+        result: list[ModelRequest | ModelResponse | HintMessage] = []
+        for msg in messages:
+            if isinstance(msg, ModelRequest):
+                new_parts: list[ModelRequestPart] = []
+                for part in msg.parts:
+                    if isinstance(part, UserPromptPart) and not isinstance(
+                        part, InternalPromptPart
+                    ):
+                        # Convert to InternalPromptPart
+                        new_parts.append(
+                            InternalPromptPart(
+                                content=part.content,
+                                timestamp=part.timestamp,
+                            )
+                        )
+                    else:
+                        new_parts.append(part)
+                result.append(ModelRequest(parts=new_parts))
+            else:
+                result.append(msg)
+        return result
+
     def _filter_system_prompts(
         self, messages: list[ModelMessage | HintMessage]
     ) -> list[ModelMessage | HintMessage]: