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

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

@@ -24,6 +24,7 @@ from textual.widgets import Button, Label, Static
 
 from shotgun.agents.agent_manager import (
     AgentManager,
+    ClarifyingQuestionsMessage,
     MessageHistoryUpdated,
     PartialResponseMessage,
 )
@@ -37,8 +38,6 @@ from shotgun.agents.models import (
     AgentDeps,
     AgentType,
     FileOperationTracker,
-    MultipleUserQuestions,
-    UserQuestion,
 )
 from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
 from shotgun.codebase.models import IndexProgress, ProgressPhase
@@ -114,6 +113,18 @@ 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 • "
@@ -151,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",
@@ -258,11 +281,16 @@ class ChatScreen(Screen[None]):
     history: PromptHistory = PromptHistory()
     messages = reactive(list[ModelMessage | HintMessage]())
     working = reactive(False)
-    question: reactive[UserQuestion | MultipleUserQuestions | 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
@@ -302,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)
@@ -392,6 +428,17 @@ 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:
@@ -399,6 +446,15 @@ class ChatScreen(Screen[None]):
             chat_history.update_messages(messages)
 
     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,
@@ -419,44 +475,6 @@ 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()
-
-            if isinstance(question, MultipleUserQuestions):
-                # Set question state - handle_submit will add Q&A to chat
-                question.current_index = 0
-                self.question = question
-
-                # Show intro message with total question count
-                num_questions = len(question.questions)
-                self.agent_manager.add_hint_message(
-                    HintMessage(message=f"I'm going to ask {num_questions} questions:")
-                )
-
-                # Show all questions in a numbered list so users can see what's coming
-                if question.questions:
-                    questions_list = "\n".join(
-                        f"{i + 1}. {q}" for i, q in enumerate(question.questions)
-                    )
-                    self.agent_manager.add_hint_message(
-                        HintMessage(message=questions_list)
-                    )
-
-                    # Now show the first question prompt to indicate where to start answering
-                    first_q = question.questions[0]
-                    self.agent_manager.add_hint_message(
-                        HintMessage(message=f"**Q1:** {first_q}")
-                    )
-            else:
-                # Handle single question (original behavior)
-                self.question = question
-                await question.result
-                self.question = None
-
-            self.deps.queue.task_done()
-
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
         with Container(id="window"):
@@ -502,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."""
@@ -548,8 +602,6 @@ class ChatScreen(Screen[None]):
 
     @on(PromptInput.Submitted)
     async def handle_submit(self, message: PromptInput.Submitted) -> None:
-        from shotgun.agents.models import UserAnswer
-
         text = message.text.strip()
 
         # If empty text, just clear input and return
@@ -559,58 +611,56 @@ class ChatScreen(Screen[None]):
             self.value = ""
             return
 
-        # Check if we're in a multi-question flow
-        if self.question and isinstance(self.question, MultipleUserQuestions):
-            q_num = self.question.current_index + 1
-
-            # Q1 already shown by handle_message_history_updated,
-            # Q2+ shown after previous answer. So we only need to add the answer to chat
-            self.agent_manager.add_hint_message(
-                HintMessage(message=f"**A{q_num}:** {text}")
-            )
+        # Handle Q&A mode (from structured output clarifying questions)
+        if self.qa_mode and self.qa_questions:
+            # Collect answer
+            self.qa_answers.append(text)
 
-            # Store the answer
-            self.question.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 question or finish
-            self.question.current_index += 1
+            # Move to next or finish
+            self.qa_current_index += 1
 
-            if self.question.current_index < len(self.question.questions):
-                # Show the next question immediately after the answer
-                next_q = self.question.questions[self.question.current_index]
-                next_q_num = self.question.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 questions answered! Format and resolve
-                formatted_qa = "\n\n".join(
-                    f"Q{i + 1}: {q}\nA{i + 1}: {a}"
-                    for i, (q, a) in enumerate(
-                        zip(self.question.questions, self.question.answers, strict=True)
+                # 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)
+                        )
                     )
-                )
-
-                # Resolve the original future with formatted Q&A (this goes to the agent)
-                final_answer = UserAnswer(
-                    answer=formatted_qa,
-                    tool_call_id=self.question.tool_call_id,
-                )
-                self.question.result.set_result(final_answer)
-
-                # Clear question state
-                self.question = None
 
-                # Clear input first
-                prompt_input = self.query_one(PromptInput)
-                prompt_input.clear()
-                self.value = ""
+                # Exit Q&A mode
+                self.qa_mode = False
+                self.qa_questions = []
+                self.qa_answers = []
+                self.qa_current_index = 0
 
-                # Send the formatted Q&A directly to the agent (no prefix needed)
+                # Send answers back to agent
                 self.run_agent(formatted_qa)
-                return
 
-            # Clear input and return
+            # Clear input
             prompt_input = self.query_one(PromptInput)
             prompt_input.clear()
             self.value = ""

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 in ("ask_user", "ask_questions")
-                    ),
-                    None,
-                )
-
-                ask_user_part = next(
-                    (
-                        part
-                        for part in next_item.parts
-                        if isinstance(part, ToolCallPart)
-                        and part.tool_name in ("ask_user", "ask_questions")
-                    ),
-                    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,12 +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)
-
-        if part.tool_name == "ask_questions":
-            return self._format_ask_questions_part(part)
-
         # Parse args once (handles both JSON string and dict)
         args = self._parse_args(part.args)
 
@@ -362,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)
@@ -385,27 +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 "❓ "
-
-    def _format_ask_questions_part(
-        self,
-        part: ToolCallPart,
-    ) -> str:
-        """Hide ask_questions tool calls - Q&A shown as HintMessages instead."""
-        return ""

{shotgun_sh-0.2.6.dev2.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.dev2
+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