shotgun-sh 0.2.6.dev1__py3-none-any.whl → 0.2.6.dev3__py3-none-any.whl

shotgun/agents/tasks.py

@@ -4,7 +4,6 @@ from functools import partial
 
 from pydantic_ai import (
     Agent,
-    DeferredToolRequests,
 )
 from pydantic_ai.agent import AgentRunResult
 from pydantic_ai.messages import ModelMessage
@@ -19,14 +18,14 @@ from .common import (
     create_usage_limits,
     run_agent,
 )
-from .models import AgentDeps, AgentRuntimeOptions, AgentType
+from .models import AgentDeps, AgentResponse, AgentRuntimeOptions, AgentType
 
 logger = get_logger(__name__)
 
 
 def create_tasks_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
-) -> tuple[Agent[AgentDeps, str | DeferredToolRequests], AgentDeps]:
+) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create a tasks agent with file management capabilities.
 
     Args:
@@ -50,11 +49,11 @@ def create_tasks_agent(
 
 
 async def run_tasks_agent(
-    agent: Agent[AgentDeps, str | DeferredToolRequests],
+    agent: Agent[AgentDeps, AgentResponse],
     instruction: str,
     deps: AgentDeps,
     message_history: list[ModelMessage] | None = None,
-) -> AgentRunResult[str | DeferredToolRequests]:
+) -> AgentRunResult[AgentResponse]:
     """Create or update tasks based on the given instruction.
 
     Args:

shotgun/agents/tools/__init__.py

@@ -8,7 +8,6 @@ from .codebase import (
     retrieve_code,
 )
 from .file_management import append_file, read_file, write_file
-from .user_interaction import ask_user
 from .web_search import (
     anthropic_web_search_tool,
     gemini_web_search_tool,
@@ -21,7 +20,6 @@ __all__ = [
     "anthropic_web_search_tool",
     "gemini_web_search_tool",
     "get_available_web_search_tools",
-    "ask_user",
     "read_file",
     "write_file",
     "append_file",

shotgun/prompts/agents/export.j2

@@ -316,7 +316,7 @@ This project is about [making assumptions without reading files]...
 USER INTERACTION - CLARIFY EXPORT REQUIREMENTS:
 
 - ALWAYS ask clarifying questions when export requirements are unclear
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Target format and file type preferences
   - Intended use case and audience for the export
   - Specific content sections to include/exclude from files

shotgun/prompts/agents/partials/common_agent_system_prompt.j2

@@ -7,7 +7,10 @@ Your extensive expertise spans, among other things:
 ## KEY RULES
 
 {% if interactive_mode %}
-0. Always ask CLARIFYING QUESTIONS if the user's request is ambiguous or lacks sufficient detail. Do not make assumptions about what the user wants.
+0. Always ask CLARIFYING QUESTIONS using structured output if the user's request is ambiguous or lacks sufficient detail.
+   - Return your response with the clarifying_questions field populated
+   - Do not make assumptions about what the user wants
+   - Questions should be clear, specific, and answerable
 {% 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/prompts/agents/partials/interactive_mode.j2

@@ -6,20 +6,37 @@
 {% if interactive_mode -%}
 IMPORTANT: USER INTERACTION IS ENABLED (interactive mode).
 
-- BEFORE GETTING TO WORK, ALWAYS THINK WHAT YOU'RE GOING TO DO AND ask_user() TO ACCEPT WHAT YOU'RE GOING TO DO.
-- ALWAYS USE ask_user TO REVIEW AND ACCEPT THE ARTIFACT SECTION YOU'VE WORKED ON BEFORE PROCEEDING TO THE NEXT SECTION.
-- AFTER USING write_artifact_section(), ALWAYS USE ask_user() TO REVIEW AND ACCEPT THE ARTIFACT SECTION YOU'VE WORKED ON BEFORE PROCEEDING TO THE NEXT SECTION.
+## Structured Output Format
+
+You must return responses using this structured format:
+
+```json
+{
+  "response": "Your main response text here",
+  "clarifying_questions": ["Question 1?", "Question 2?"]  // Optional, only when needed
+}
+```
+
+## When to Use Clarifying Questions
+
+- BEFORE GETTING TO WORK: If the user's request is ambiguous, use clarifying_questions to ask what they want
+- DURING WORK: After using write_file(), you can suggest that the user review it and ask any clarifying questions with clarifying_questions
 - Don't assume - ask for confirmation of your understanding
-- When in doubt about any aspect of the goal, ASK before proceeding
+- When in doubt about any aspect of the goal, include clarifying_questions
+
+## Important Notes
+
+- If you don't need to ask questions, set clarifying_questions to null or omit it
+- Keep response field concise - a paragraph at most for user communication
+- Questions should be clear, specific, and independently answerable
+- Don't ask multiple questions in one string - use separate array items
 
 {% else -%}
 
 IMPORTANT: USER INTERACTION IS DISABLED (non-interactive mode).
-- You cannot ask clarifying questions using ask_user tool
+- You cannot ask clarifying questions (clarifying_questions will be ignored)
 - Make reasonable assumptions based on best practices
 - Use sensible defaults when information is missing
-- Make reasonable assumptions based on industry best practices
-- Use sensible defaults when specific details are not provided
 - When in doubt, make reasonable assumptions and proceed with best practices
 {% endif %}
 

shotgun/prompts/agents/plan.j2

@@ -118,7 +118,7 @@ USER INTERACTION - REDUCE UNCERTAINTY:
 - FIRST read `research.md` and `specification.md` before asking ANY questions
 - ONLY ask clarifying questions AFTER reading the context files
 - Questions should be about gaps not covered in research/specification
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Information not found in the context files
   - Clarifications on ambiguous specifications
   - Priorities when multiple options exist

shotgun/prompts/agents/research.j2

@@ -39,7 +39,7 @@ For research tasks:
 ## RESEARCH PRINCIPLES
 
 {% if interactive_mode -%}
-- CRITICAL: BEFORE RUNNING ANY SEARCH TOOL, ASK THE USER FOR APPROVAL USING ask_user(). FINISH THE QUESTION WITH ASKING FOR A GO AHEAD.
+- CRITICAL: BEFORE RUNNING ANY SEARCH TOOL, ASK THE USER FOR APPROVAL using clarifying questions. Include what you plan to search for and ask if they want you to proceed.
 {% endif -%}
 - Build upon existing research rather than starting from scratch
 - Focus on practical, actionable information over theoretical concepts

shotgun/prompts/agents/tasks.j2

@@ -99,7 +99,7 @@ Then organize tasks into logical sections:
 USER INTERACTION - ASK CLARIFYING QUESTIONS:
 
 - ALWAYS ask clarifying questions when the request is vague or ambiguous
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Specific features or functionality to prioritize
   - Technical constraints or preferences
   - Timeline and resource constraints

shotgun/telemetry.py

@@ -65,6 +65,14 @@ def setup_logfire_observability() -> bool:
         # Instrument Pydantic AI for better observability
         logfire.instrument_pydantic_ai()
 
+        # Add LogfireLoggingHandler to root logger so logfire logs also go to file
+        import logging
+
+        root_logger = logging.getLogger()
+        logfire_handler = logfire.LogfireLoggingHandler()
+        root_logger.addHandler(logfire_handler)
+        logger.debug("Added LogfireLoggingHandler to root logger for file integration")
+
         # Set user context using baggage for all logs and spans
         try:
             from opentelemetry import baggage, context

shotgun/tui/screens/chat.py

@@ -20,10 +20,11 @@ from textual.keys import Keys
 from textual.reactive import reactive
 from textual.screen import ModalScreen, Screen
 from textual.widget import Widget
-from textual.widgets import Button, Label, Markdown, Static
+from textual.widgets import Button, Label, Static
 
 from shotgun.agents.agent_manager import (
     AgentManager,
+    ClarifyingQuestionsMessage,
     MessageHistoryUpdated,
     PartialResponseMessage,
 )
@@ -37,7 +38,6 @@ from shotgun.agents.models import (
     AgentDeps,
     AgentType,
     FileOperationTracker,
-    UserQuestion,
 )
 from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
 from shotgun.codebase.models import IndexProgress, ProgressPhase
@@ -113,10 +113,31 @@ class StatusBar(Widget):
         self.working = working
 
     def render(self) -> str:
+        # Check if in Q&A mode first (highest priority)
+        try:
+            chat_screen = self.screen
+            if isinstance(chat_screen, ChatScreen) and chat_screen.qa_mode:
+                return (
+                    "[$foreground-muted][bold $text]esc[/] to exit Q&A mode • "
+                    "[bold $text]enter[/] to send answer • [bold $text]ctrl+j[/] for newline[/]"
+                )
+        except Exception:  # noqa: S110
+            # If we can't access chat screen, continue with normal display
+            pass
+
         if self.working:
-            return """[$foreground-muted][bold $text]esc[/] to stop • [bold $text]enter[/] to send • [bold $text]ctrl+j[/] for newline • [bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • /help for commands[/]"""
+            return (
+                "[$foreground-muted][bold $text]esc[/] to stop • "
+                "[bold $text]enter[/] to send • [bold $text]ctrl+j[/] for newline • "
+                "[bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • "
+                "/help for commands[/]"
+            )
         else:
-            return """[$foreground-muted][bold $text]enter[/] to send • [bold $text]ctrl+j[/] for newline • [bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • /help for commands[/]"""
+            return (
+                "[$foreground-muted][bold $text]enter[/] to send • "
+                "[bold $text]ctrl+j[/] for newline • [bold $text]ctrl+p[/] command palette • "
+                "[bold $text]shift+tab[/] cycle modes • /help for commands[/]"
+            )
 
 
 class ModeIndicator(Widget):
@@ -141,6 +162,18 @@ class ModeIndicator(Widget):
 
     def render(self) -> str:
         """Render the mode indicator."""
+        # Check if in Q&A mode first
+        try:
+            chat_screen = self.screen
+            if isinstance(chat_screen, ChatScreen) and chat_screen.qa_mode:
+                return (
+                    "[bold $text-accent]Q&A mode[/]"
+                    "[$foreground-muted] (Answer the clarifying questions or ESC to cancel)[/]"
+                )
+        except Exception:  # noqa: S110
+            # If we can't access chat screen, continue with normal display
+            pass
+
         mode_display = {
             AgentType.RESEARCH: "Research",
             AgentType.PLAN: "Planning",
@@ -149,10 +182,16 @@ class ModeIndicator(Widget):
             AgentType.EXPORT: "Export",
         }
         mode_description = {
-            AgentType.RESEARCH: "Research topics with web search and synthesize findings",
+            AgentType.RESEARCH: (
+                "Research topics with web search and synthesize findings"
+            ),
             AgentType.PLAN: "Create comprehensive, actionable plans with milestones",
-            AgentType.TASKS: "Generate specific, actionable tasks from research and plans",
-            AgentType.SPECIFY: "Create detailed specifications and requirements documents",
+            AgentType.TASKS: (
+                "Generate specific, actionable tasks from research and plans"
+            ),
+            AgentType.SPECIFY: (
+                "Create detailed specifications and requirements documents"
+            ),
             AgentType.EXPORT: "Export artifacts and findings to various formats",
         }
 
@@ -163,7 +202,10 @@ class ModeIndicator(Widget):
         has_content = self.progress_checker.has_mode_content(self.mode)
         status_icon = " ✓" if has_content else ""
 
-        return f"[bold $text-accent]{mode_title}{status_icon} mode[/][$foreground-muted] ({description})[/]"
+        return (
+            f"[bold $text-accent]{mode_title}{status_icon} mode[/]"
+            f"[$foreground-muted] ({description})[/]"
+        )
 
 
 class CodebaseIndexPromptScreen(ModalScreen[bool]):
@@ -199,7 +241,8 @@ class CodebaseIndexPromptScreen(ModalScreen[bool]):
             yield Static(
                 f"Would you like to index the codebase at:\n{Path.cwd()}\n\n"
                 "This is required for the agent to understand your code and answer "
-                "questions about it. Without indexing, the agent cannot analyze your codebase."
+                "questions about it. Without indexing, the agent cannot analyze "
+                "your codebase."
             )
             with Container(id="index-prompt-buttons"):
                 yield Button(
@@ -238,11 +281,16 @@ class ChatScreen(Screen[None]):
     history: PromptHistory = PromptHistory()
     messages = reactive(list[ModelMessage | HintMessage]())
     working = reactive(False)
-    question: reactive[UserQuestion | None] = reactive(None)
     indexing_job: reactive[CodebaseIndexSelection | None] = reactive(None)
     partial_message: reactive[ModelMessage | None] = reactive(None)
     _current_worker = None  # Track the current running worker for cancellation
 
+    # Q&A mode state (for structured output clarifying questions)
+    qa_mode = reactive(False)
+    qa_questions: list[str] = []
+    qa_current_index = reactive(0)
+    qa_answers: list[str] = []
+
     def __init__(self, continue_session: bool = False) -> None:
         super().__init__()
         # Get the model configuration and services
@@ -282,11 +330,19 @@ class ChatScreen(Screen[None]):
             self._load_conversation()
 
         self.call_later(self.check_if_codebase_is_indexed)
-        # Start the question listener worker to handle ask_user interactions
-        self.call_later(self.add_question_listener)
 
     async def on_key(self, event: events.Key) -> None:
         """Handle key presses for cancellation."""
+        # If escape is pressed during Q&A mode, exit Q&A
+        if event.key in (Keys.Escape, Keys.ControlC) and self.qa_mode:
+            self._exit_qa_mode()
+            # Re-enable the input
+            prompt_input = self.query_one(PromptInput)
+            prompt_input.focus()
+            # Prevent the event from propagating (don't quit the app)
+            event.stop()
+            return
+
         # If escape or ctrl+c is pressed while agent is working, cancel the operation
         if (
             event.key in (Keys.Escape, Keys.ControlC)
@@ -372,24 +428,33 @@ class ChatScreen(Screen[None]):
             status_bar.working = is_working
             status_bar.refresh()
 
+    def watch_qa_mode(self, qa_mode_active: bool) -> None:
+        """Update UI when Q&A mode state changes."""
+        if self.is_mounted:
+            # Update status bar to show "ESC to exit Q&A mode"
+            status_bar = self.query_one(StatusBar)
+            status_bar.refresh()
+
+            # Update mode indicator to show "Q&A mode"
+            mode_indicator = self.query_one(ModeIndicator)
+            mode_indicator.refresh()
+
     def watch_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
         """Update the chat history when messages change."""
         if self.is_mounted:
             chat_history = self.query_one(ChatHistory)
             chat_history.update_messages(messages)
 
-    def watch_question(self, question: UserQuestion | None) -> None:
-        """Update the question display."""
-        if self.is_mounted:
-            question_display = self.query_one("#question-display", Markdown)
-            if question:
-                question_display.update(f"Question:\n\n{question.question}")
-                question_display.display = True
-            else:
-                question_display.update("")
-                question_display.display = False
-
     def action_toggle_mode(self) -> None:
+        # Prevent mode switching during Q&A
+        if self.qa_mode:
+            self.notify(
+                "Cannot switch modes while answering questions",
+                severity="warning",
+                timeout=3,
+            )
+            return
+
         modes = [
             AgentType.RESEARCH,
             AgentType.SPECIFY,
@@ -410,20 +475,11 @@ class ChatScreen(Screen[None]):
         else:
             self.notify("No usage hint available", severity="error")
 
-    @work
-    async def add_question_listener(self) -> None:
-        while True:
-            question = await self.deps.queue.get()
-            self.question = question
-            await question.result
-            self.deps.queue.task_done()
-
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
         with Container(id="window"):
             yield self.agent_manager
             yield ChatHistory()
-            yield Markdown(markdown="", id="question-display")
             with Container(id="footer"):
                 yield Spinner(
                     text="Processing...",
@@ -464,6 +520,42 @@ class ChatScreen(Screen[None]):
         partial_response_widget = self.query_one(ChatHistory)
         partial_response_widget.partial_response = None
 
+    def _exit_qa_mode(self) -> None:
+        """Exit Q&A mode and clean up state."""
+        # Track cancellation event
+        track_event(
+            "qa_mode_cancelled",
+            {
+                "questions_total": len(self.qa_questions),
+                "questions_answered": len(self.qa_answers),
+            },
+        )
+
+        # Clear Q&A state
+        self.qa_mode = False
+        self.qa_questions = []
+        self.qa_answers = []
+        self.qa_current_index = 0
+
+        # Show cancellation message
+        self.mount_hint("⚠️ Q&A cancelled - You can continue the conversation.")
+
+    @on(ClarifyingQuestionsMessage)
+    def handle_clarifying_questions(self, event: ClarifyingQuestionsMessage) -> None:
+        """Handle clarifying questions from agent structured output.
+
+        Note: Hints are now added synchronously in agent_manager.run() before this
+        handler is called, so we only need to set up Q&A mode state here.
+        """
+        # Clear any streaming partial response (removes final_result JSON)
+        self._clear_partial_response()
+
+        # Enter Q&A mode
+        self.qa_mode = True
+        self.qa_questions = event.questions
+        self.qa_current_index = 0
+        self.qa_answers = []
+
     @on(MessageHistoryUpdated)
     def handle_message_history_updated(self, event: MessageHistoryUpdated) -> None:
         """Handle message history updates from the agent manager."""
@@ -519,6 +611,61 @@ class ChatScreen(Screen[None]):
             self.value = ""
             return
 
+        # Handle Q&A mode (from structured output clarifying questions)
+        if self.qa_mode and self.qa_questions:
+            # Collect answer
+            self.qa_answers.append(text)
+
+            # Show answer
+            if len(self.qa_questions) == 1:
+                self.agent_manager.add_hint_message(
+                    HintMessage(message=f"**A:** {text}")
+                )
+            else:
+                q_num = self.qa_current_index + 1
+                self.agent_manager.add_hint_message(
+                    HintMessage(message=f"**A{q_num}:** {text}")
+                )
+
+            # Move to next or finish
+            self.qa_current_index += 1
+
+            if self.qa_current_index < len(self.qa_questions):
+                # Show next question
+                next_q = self.qa_questions[self.qa_current_index]
+                next_q_num = self.qa_current_index + 1
+                self.agent_manager.add_hint_message(
+                    HintMessage(message=f"**Q{next_q_num}:** {next_q}")
+                )
+            else:
+                # All answered - format and send back
+                if len(self.qa_questions) == 1:
+                    # Single question - just send the answer
+                    formatted_qa = f"Q: {self.qa_questions[0]}\nA: {self.qa_answers[0]}"
+                else:
+                    # Multiple questions - format all Q&A pairs
+                    formatted_qa = "\n\n".join(
+                        f"Q{i + 1}: {q}\nA{i + 1}: {a}"
+                        for i, (q, a) in enumerate(
+                            zip(self.qa_questions, self.qa_answers, strict=True)
+                        )
+                    )
+
+                # Exit Q&A mode
+                self.qa_mode = False
+                self.qa_questions = []
+                self.qa_answers = []
+                self.qa_current_index = 0
+
+                # Send answers back to agent
+                self.run_agent(formatted_qa)
+
+            # Clear input
+            prompt_input = self.query_one(PromptInput)
+            prompt_input.clear()
+            self.value = ""
+            return
+
         # Check if it's a command
         if self.command_handler.is_command(text):
             success, response = self.command_handler.handle_command(text)
@@ -785,7 +932,9 @@ class ChatScreen(Screen[None]):
 
 def help_text_with_codebase(already_indexed: bool = False) -> str:
     return (
-        "Howdy! Welcome to Shotgun - the context tool for software engineering. \n\nYou can research, build specs, plan, create tasks, and export context to your favorite code-gen agents.\n\n"
+        "Howdy! Welcome to Shotgun - the context tool for software engineering. \n\n"
+        "You can research, build specs, plan, create tasks, and export context to your "
+        "favorite code-gen agents.\n\n"
         f"{'' if already_indexed else 'Once your codebase is indexed, '}I can help with:\n\n"
         "- Speccing out a new feature\n"
         "- Onboarding you onto this project\n"
@@ -796,7 +945,9 @@ def help_text_with_codebase(already_indexed: bool = False) -> str:
 
 def help_text_empty_dir() -> str:
     return (
-        "Howdy! Welcome to Shotgun - the context tool for software engineering.\n\nYou can research, build specs, plan, create tasks, and export context to your favorite code-gen agents.\n\n"
+        "Howdy! Welcome to Shotgun - the context tool for software engineering.\n\n"
+        "You can research, build specs, plan, create tasks, and export context to your "
+        "favorite code-gen agents.\n\n"
         "What would you like to build? Here are some examples:\n\n"
         "- Research FastAPI vs Django\n"
         "- Plan my new web app using React\n"

shotgun/tui/screens/chat_screen/history.py

@@ -19,7 +19,6 @@ from textual.reactive import reactive
 from textual.widget import Widget
 from textual.widgets import Markdown
 
-from shotgun.agents.models import UserAnswer
 from shotgun.tui.components.vertical_tail import VerticalTail
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage, HintMessageWidget
 
@@ -103,42 +102,8 @@ class ChatHistory(Widget):
         self._rendered_count = len(filtered)
 
     def filtered_items(self) -> Generator[ModelMessage | HintMessage, None, None]:
-        for idx, next_item in enumerate(self.items):
-            prev_item = self.items[idx - 1] if idx > 0 else None
-
-            if isinstance(prev_item, ModelRequest) and isinstance(
-                next_item, ModelResponse
-            ):
-                ask_user_tool_response_part = next(
-                    (
-                        part
-                        for part in prev_item.parts
-                        if isinstance(part, ToolReturnPart)
-                        and part.tool_name == "ask_user"
-                    ),
-                    None,
-                )
-
-                ask_user_part = next(
-                    (
-                        part
-                        for part in next_item.parts
-                        if isinstance(part, ToolCallPart)
-                        and part.tool_name == "ask_user"
-                    ),
-                    None,
-                )
-
-                if not ask_user_part or not ask_user_tool_response_part:
-                    yield next_item
-                    continue
-                if (
-                    ask_user_tool_response_part.tool_call_id
-                    == ask_user_part.tool_call_id
-                ):
-                    continue  # don't emit tool call that happens after tool response
-
-            yield next_item
+        # Simply yield all items - no filtering needed now that ask_user/ask_questions are gone
+        yield from self.items
 
     def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
         """Update the displayed messages using incremental mounting."""
@@ -167,6 +132,9 @@ class ChatHistory(Widget):
 
             self._rendered_count = len(filtered)
 
+            # Scroll to bottom to show newly added messages
+            self.vertical_tail.scroll_end(animate=False)
+
 
 class UserQuestionWidget(Widget):
     def __init__(self, item: ModelRequest | None) -> None:
@@ -189,13 +157,8 @@ class UserQuestionWidget(Widget):
                     f"**>** {part.content if isinstance(part.content, str) else ''}\n\n"
                 )
             elif isinstance(part, ToolReturnPart):
-                if part.tool_name == "ask_user":
-                    acc += f"**>** {part.content.answer if isinstance(part.content, UserAnswer) else part.content['answer']}\n\n"
-                else:
-                    # acc += "  ∟ finished\n\n"  # let's not show anything yet
-                    pass
-            elif isinstance(part, UserPromptPart):
-                acc += f"**>** {part.content}\n\n"
+                # Don't show tool return parts in the UI
+                pass
         return acc
 
 
@@ -216,23 +179,15 @@ class AgentResponseWidget(Widget):
         if self.item is None:
             return ""
 
-        # Check if there's an ask_user tool call
-        has_ask_user = any(
-            isinstance(part, ToolCallPart) and part.tool_name == "ask_user"
-            for part in self.item.parts
-        )
-
         for idx, part in enumerate(self.item.parts):
             if isinstance(part, TextPart):
-                # Skip ALL text parts if there's an ask_user tool call
-                if has_ask_user:
-                    continue
                 # Only show the circle prefix if there's actual content
                 if part.content and part.content.strip():
                     acc += f"**⏺** {part.content}\n\n"
             elif isinstance(part, ToolCallPart):
                 parts_str = self._format_tool_call_part(part)
-                acc += parts_str + "\n\n"
+                if parts_str:  # Only add if there's actual content
+                    acc += parts_str + "\n\n"
             elif isinstance(part, BuiltinToolCallPart):
                 # Format builtin tool calls better
                 if part.tool_name and "search" in part.tool_name.lower():
@@ -286,9 +241,6 @@ class AgentResponseWidget(Widget):
         return args if isinstance(args, dict) else {}
 
     def _format_tool_call_part(self, part: ToolCallPart) -> str:
-        if part.tool_name == "ask_user":
-            return self._format_ask_user_part(part)
-
         # Parse args once (handles both JSON string and dict)
         args = self._parse_args(part.args)
 
@@ -359,10 +311,9 @@ class AgentResponseWidget(Widget):
                 return f"{part.tool_name}({args['section_title']})"
             return f"{part.tool_name}()"
 
-        if part.tool_name == "create_artifact":
-            if "name" in args:
-                return f"{part.tool_name}({args['name']})"
-            return f"▪ {part.tool_name}()"
+        if part.tool_name == "final_result":
+            # Hide final_result tool calls completely - they're internal Pydantic AI mechanics
+            return ""
 
         # Default case for unrecognized tools - format args properly
         args = self._parse_args(part.args)
@@ -382,20 +333,3 @@ class AgentResponseWidget(Widget):
                 return f"{part.tool_name}({args_str})"
         else:
             return f"{part.tool_name}()"
-
-    def _format_ask_user_part(
-        self,
-        part: ToolCallPart,
-    ) -> str:
-        if isinstance(part.args, str):
-            try:
-                _args = json.loads(part.args) if part.args.strip() else {}
-            except json.JSONDecodeError:
-                _args = {}
-        else:
-            _args = part.args
-
-        if isinstance(_args, dict) and "question" in _args:
-            return f"{_args['question']}"
-        else:
-            return "❓ "

{shotgun_sh-0.2.6.dev1.dist-info → shotgun_sh-0.2.6.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.6.dev1
+Version: 0.2.6.dev3
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun