tau-coding-agent 0.6.1__tar.gz → 0.6.2__tar.gz

{tau_coding_agent-0.6.1/tau_coding_agent.egg-info → tau_coding_agent-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.6.1
+Version: 0.6.2
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{tau_coding_agent-0.6.1 → tau_coding_agent-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.6.1"
+version = "0.6.2"
 description = "A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands"
 readme = "README.md"
 requires-python = ">=3.12"

{tau_coding_agent-0.6.1 → tau_coding_agent-0.6.2}/tau/agent/service.py

@@ -20,6 +20,7 @@ from tau.message.utils import strip_unusable_trailing_assistant
 from tau.session.compaction import CompactionSettings
 from tau.session.utils import to_llm_messages as _to_llm_messages
 from tau.tool.types import ToolInvocation, ToolResult
+from tau.utils.format import human_size as _fmt_size
 
 _log = logging.getLogger(__name__)
 
@@ -33,14 +34,6 @@ _TOOL_CAP_LINES = 2000  # DEFAULT_MAX_LINES
 _TOOL_LINE_CAP_BYTES = 2 * 1024  # 2 KB — max bytes for a single line
 
 
-def _fmt_size(n: int) -> str:
-    if n < 1024:
-        return f"{n}B"
-    if n < 1024 * 1024:
-        return f"{n / 1024:.1f}KB"
-    return f"{n / (1024 * 1024):.1f}MB"
-
-
 if TYPE_CHECKING:
     from tau.engine.service import Engine
     from tau.runtime.service import Runtime

{tau_coding_agent-0.6.1 → tau_coding_agent-0.6.2}/tau/builtins/extensions/ask_user/component.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+import textwrap
 from typing import TYPE_CHECKING, Any
 
-from schema import AskUserOption  # type: ignore[import-not-found]
+from schema import FREEFORM_LABEL, AskUserOption  # type: ignore[import-not-found]
 
 from tau.tui.component import Component
 from tau.tui.input import InputEvent, KeyEvent
@@ -11,8 +12,6 @@ if TYPE_CHECKING:
     from tau.tui.buffer import Buffer
     from tau.tui.geometry import Rect
 
-FREEFORM_LABEL = "Type something…"
-
 
 def _typed_char(event: KeyEvent) -> str | None:
     """Return the printable character a key event represents, or None.
@@ -34,6 +33,12 @@ class _AskUserComponent(Component):
     ML_VISIBLE_ROWS = 8
     ML_MIN_VISIBLE_ROWS = 4  # pad short buffers so the box visibly reads as multi-line
 
+    # Below this total width there's no room for a legible side-by-side preview
+    # column, so the option list just falls back to full width with no preview.
+    PREVIEW_MIN_TOTAL_WIDTH = 70
+    PREVIEW_GAP = 2
+    PREVIEW_MIN_BOX_HEIGHT = 6
+
     def __init__(
         self,
         question: str,
@@ -85,96 +90,206 @@ class _AskUserComponent(Component):
 
     # ── Render ────────────────────────────────────────────────────────────
 
+    def _has_preview_capable_options(self) -> bool:
+        return not self._allow_multiple and any(o.preview for o in self._options)
+
     def render_cells(self, area: Rect, buf: Buffer) -> int:
         from tau.tui.ansi_bridge import parse_ansi_wrapped_into
 
-        def _plain(lines: list[str]) -> int:
+        def _write(lines: list[str], x: int, y: int, width: int) -> int:
             row = 0
             for line in lines:
-                row += parse_ansi_wrapped_into(buf, area.x, area.y + row, line, area.width)
+                row += parse_ansi_wrapped_into(buf, x, y + row, line, width)
             return row
 
-        inner: list[str] = []
+        header: list[str] = []
         if self._context:
             for line in self._context.splitlines():
-                inner.append(f"  \x1b[2m{line}\x1b[0m")
-            inner.append("")
-        inner.append(f"  \x1b[1m{self._question}\x1b[0m")
-        inner.append("")
-
+                header.append(f"  \x1b[2m{line}\x1b[0m")
+            header.append("")
+        header.append(f"  \x1b[1m{self._question}\x1b[0m")
+        header.append("")
+
+        header_rows = _write(header, area.x, area.y, area.width)
+        body_y = area.y + header_rows
+
+        show_preview = (
+            self._has_preview_capable_options() and area.width >= self.PREVIEW_MIN_TOTAL_WIDTH
+        )
+
+        left_width = min(46, max(30, area.width // 3)) if show_preview else area.width
+        content_lines, footer_lines = self._build_body_lines(left_width)
+
+        if not show_preview:
+            body_rows = _write(content_lines, area.x, body_y, area.width)
+            footer_rows = _write(footer_lines, area.x, body_y + body_rows, area.width)
+            return header_rows + body_rows + footer_rows
+
+        right_width = area.width - left_width - self.PREVIEW_GAP
+
+        preview: str | None = None
+        if self._cursor != self._freeform_index and self._options:
+            preview = self._options[self._cursor].preview
+
+        box_height = max(len(content_lines), self.PREVIEW_MIN_BOX_HEIGHT)
+        preview_box = self._build_preview_box(preview, right_width, box_height)
+
+        left_rows = _write(content_lines, area.x, body_y, left_width)
+        right_rows = _write(preview_box, area.x + left_width + self.PREVIEW_GAP, body_y, right_width)
+        col_rows = max(left_rows, right_rows)
+
+        # Footer spans the FULL width beneath both columns — it's not part of
+        # either column, so it never wraps just because the left column is
+        # narrow, and it visually separates from the preview box like the
+        # bottom nav-hint line in the reference screenshot.
+        footer_rows = _write(footer_lines, area.x, body_y + col_rows, area.width)
+        return header_rows + col_rows + footer_rows
+
+    def _build_body_lines(self, width: int) -> tuple[list[str], list[str]]:
+        """Everything below the header: the option list, or whichever freeform
+        editor is active. ``width`` is whatever column this ends up rendered
+        in (full width, or the left column next to a preview pane) — used to
+        wrap option descriptions so they don't run into the next row.
+
+        Returns ``(content_lines, footer_lines)``. The footer is kept separate
+        from the content so the caller can always render it full-width, even
+        when the content itself is confined to a narrow left column.
+        """
         if self._mode == "freeform" and self._multiline:
-            self._clamp_ml_scroll()
-            limit = self._ml_scroll_top + self.ML_VISIBLE_ROWS
-            visible = self._ml_lines[self._ml_scroll_top : limit]
-            for ri, line in enumerate(visible):
-                abs_row = self._ml_scroll_top + ri
-                if abs_row == self._ml_cursor_row:
-                    before = line[: self._ml_cursor_col]
-                    after = line[self._ml_cursor_col :]
-                    inner.append(f"  {before}█{after}")
-                else:
-                    inner.append(f"  {line}")
-            # Pad with blank rows (display-only, not part of the buffer) so an
-            # empty/short answer still shows several rows — a visible cue that
-            # this is a multi-line editor, not a single-line box.
-            for _ in range(self.ML_MIN_VISIBLE_ROWS - len(visible)):
-                inner.append("")
-            total = len(self._ml_lines)
-            if total > self.ML_VISIBLE_ROWS:
-                pct = int(self._ml_scroll_top / max(1, total - self.ML_VISIBLE_ROWS) * 100)
-                inner.append(f"  \x1b[2m↕ {pct}%\x1b[0m")
-            else:
-                inner.append("")
-            back = "Esc to cancel" if not self._options else "Esc to go back"
-            inner.append(
-                "  \x1b[2mEnter to submit  ·  \\+Enter or Shift+Enter for newline  ·  "
-                f"{back}\x1b[0m"
-            )
-            return _plain(inner)
-
+            return self._build_multiline_body()
         if self._mode == "freeform":
-            inner.append(f"  {self._freeform_value}█")
+            return self._build_singleline_body()
+        return self._build_list_body(width)
+
+    def _build_multiline_body(self) -> tuple[list[str], list[str]]:
+        inner: list[str] = []
+        self._clamp_ml_scroll()
+        limit = self._ml_scroll_top + self.ML_VISIBLE_ROWS
+        visible = self._ml_lines[self._ml_scroll_top : limit]
+        for ri, line in enumerate(visible):
+            abs_row = self._ml_scroll_top + ri
+            if abs_row == self._ml_cursor_row:
+                before = line[: self._ml_cursor_col]
+                after = line[self._ml_cursor_col :]
+                inner.append(f"  {before}█{after}")
+            else:
+                inner.append(f"  {line}")
+        # Pad with blank rows (display-only, not part of the buffer) so an
+        # empty/short answer still shows several rows — a visible cue that
+        # this is a multi-line editor, not a single-line box.
+        for _ in range(self.ML_MIN_VISIBLE_ROWS - len(visible)):
+            inner.append("")
+        total = len(self._ml_lines)
+        if total > self.ML_VISIBLE_ROWS:
+            pct = int(self._ml_scroll_top / max(1, total - self.ML_VISIBLE_ROWS) * 100)
+            inner.append(f"  \x1b[2m↕ {pct}%\x1b[0m")
+        else:
             inner.append("")
-            back = "Esc to cancel" if not self._options else "Esc to go back"
-            inner.append(f"  \x1b[2mEnter to submit  ·  {back}\x1b[0m")
-            return _plain(inner)
+        back = "Esc to cancel" if not self._options else "Esc to go back"
+        footer = [
+            "",
+            "  \x1b[2mEnter to submit  ·  \\+Enter or Shift+Enter for newline  ·  "
+            f"{back}\x1b[0m",
+        ]
+        return inner, footer
+
+    def _build_singleline_body(self) -> tuple[list[str], list[str]]:
+        back = "Esc to cancel" if not self._options else "Esc to go back"
+        content = [f"  {self._freeform_value}█"]
+        footer = ["", f"  \x1b[2mEnter to submit  ·  {back}\x1b[0m"]
+        return content, footer
+
+    # Left margin + hanging indent for wrapped description lines beneath a
+    # title row — matches the "  ❯ 1. " prefix width closely enough to read as
+    # aligned without having to compute each row's exact glyph width.
+    DESC_INDENT = "      "
+
+    def _build_list_body(self, width: int) -> tuple[list[str], list[str]]:
+        inner: list[str] = []
+        desc_width = max(width - len(self.DESC_INDENT), 10)
 
         for i in range(self._row_count):
             is_freeform_row = i == self._freeform_index
             title = FREEFORM_LABEL if is_freeform_row else self._options[i].title
             desc = "" if is_freeform_row else (self._options[i].description or "")
             is_cursor = i == self._cursor
-            cursor_mark = "›" if is_cursor else " "
-
-            if self._allow_multiple and not is_freeform_row:
-                # Same tick glyphs as the /extensions config panel. Cursor rows
-                # get wrapped in reverse-video below, so leave them uncolored
-                # there — an embedded reset would cut the highlight short.
+            cursor_mark = "❯" if is_cursor else " "
+
+            if is_freeform_row:
+                # Synthetic action row, not a countable option — keeps its own
+                # "❯" marker instead of a number.
+                marker = " ❯ "
+            elif self._allow_multiple:
+                # Same tick glyphs as the /extensions config panel, paired with
+                # the option's ordinal number. Cursor rows get wrapped in
+                # reverse-video below, so leave them uncolored here — an
+                # embedded reset would cut the highlight short.
                 if i in self._checked:
                     box = "✔" if is_cursor else "\x1b[32m✔\x1b[0m"
                 else:
                     box = "✖" if is_cursor else "\x1b[2m✖\x1b[0m"
-            elif not is_freeform_row:
-                # Radio-style circles: filled at the cursor position, hollow
-                # elsewhere. Same reverse-video caveat as the checkbox ticks
-                # above — leave the cursor row's glyph uncolored.
-                box = "●" if is_cursor else "\x1b[2m○\x1b[0m"
+                marker = f"{i + 1}. {box}"
             else:
-                box = " > "
+                marker = f"{i + 1}."
 
-            row = f"  {cursor_mark} {box} {title}"
+            row = f"  {cursor_mark} {marker} {title}"
             if is_cursor:
                 row = f"\x1b[7m{row}\x1b[0m"
-            if desc:
-                row += f"  \x1b[2m{desc}\x1b[0m"
             inner.append(row)
 
-        inner.append("")
+            # Description on its own hanging-indented line(s) below the title,
+            # not packed onto the title row — at left-column widths that
+            # would run straight into the next option's row.
+            for line in textwrap.wrap(desc, desc_width) if desc else []:
+                inner.append(f"{self.DESC_INDENT}\x1b[2m{line}\x1b[0m")
+
         hints = ["↑/↓ move", "Enter confirm", "Esc cancel"]
         if self._allow_multiple:
             hints.insert(1, "Space toggle")
-        inner.append("  \x1b[2m" + "  ·  ".join(hints) + "\x1b[0m")
-        return _plain(inner)
+        footer = ["", "  \x1b[2m" + "  ·  ".join(hints) + "\x1b[0m"]
+        return inner, footer
+
+    @staticmethod
+    def _build_preview_box(preview: str | None, width: int, height: int) -> list[str]:
+        """A bordered box of exactly ``height`` lines, sized to ``width``.
+
+        Content beyond the available rows is truncated with a "N lines hidden"
+        footer rather than growing the box — the box height is pinned to the
+        paired option list so the two columns stay aligned row-for-row.
+        """
+        dim, reset = "\x1b[2m", "\x1b[0m"
+        inner_width = max(width - 4, 4)
+        top = f"{dim}┌{'─' * (width - 2)}┐{reset}"
+        bottom = f"{dim}└{'─' * (width - 2)}┘{reset}"
+        content_rows = max(height - 2, 1)
+
+        def pad(text: str) -> str:
+            return text + " " * max(0, inner_width - len(text))
+
+        def framed(text: str) -> str:
+            return f"{dim}│{reset} {pad(text)} {dim}│{reset}"
+
+        if not preview:
+            body = [framed("(no preview for this option)" if content_rows else "")]
+            body += [framed("") for _ in range(content_rows - len(body))]
+            return [top, *body[:content_rows], bottom]
+
+        import textwrap
+
+        wrapped: list[str] = []
+        for src_line in preview.splitlines() or [""]:
+            wrapped.extend(textwrap.wrap(src_line, inner_width) or [""])
+
+        if len(wrapped) > content_rows:
+            visible = wrapped[: max(content_rows - 1, 1)]
+            hidden = len(wrapped) - len(visible)
+            footer = f"✂ {hidden} lines hidden".center(inner_width)
+            body = [framed(line) for line in visible] + [framed(footer)]
+        else:
+            body = [framed(line) for line in wrapped]
+            body += [framed("") for _ in range(content_rows - len(body))]
+
+        return [top, *body[:content_rows], bottom]
 
     # ── Input ─────────────────────────────────────────────────────────────
 

tau_coding_agent-0.6.2/tau/builtins/extensions/ask_user/schema.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+MAX_QUESTIONS = 4
+MIN_OPTIONS = 2
+MAX_OPTIONS = 4
+MAX_LABEL_LENGTH = 60
+
+FREEFORM_LABEL = "Type something…"
+
+
+class AskUserOption(BaseModel):
+    title: str
+    description: str | None = None
+    preview: str | None = Field(
+        default=None,
+        description=(
+            "Optional preview content shown when this option is focused — an ASCII "
+            "mockup, code snippet, diagram, or config example the user needs to see "
+            "to compare choices. Markdown/plain text, multi-line supported. Only "
+            "supported on single-select questions (allow_multiple=False)."
+        ),
+    )
+
+
+class AskUserQuestion(BaseModel):
+    question: str = Field(..., description="The question to ask the user")
+    context: str | None = Field(
+        default=None, description="Relevant context summary shown before the question"
+    )
+    options: list[str | AskUserOption] | None = Field(
+        default=None,
+        description=(
+            f"Multiple-choice options ({MIN_OPTIONS}-{MAX_OPTIONS} when provided). "
+            "Each needs a concise title (1-5 words); a description explaining the "
+            "trade-off is recommended. Do not author a 'Type something…' option "
+            "yourself — it is appended automatically when allow_freeform is true. "
+            "If you recommend a specific option, list it first and append "
+            '"(Recommended)" to its title.'
+        ),
+    )
+    allow_multiple: bool = Field(default=False, description="Allow selecting more than one option")
+    allow_freeform: bool = Field(
+        default=True, description="Offer a 'Type something' freeform option"
+    )
+    multiline: bool = Field(
+        default=False,
+        description=(
+            "Use a multi-line text editor for the freeform answer instead of a single "
+            "line — set this for open-ended, long-form answers (e.g. 'write your bio', "
+            "'describe the requirements'). Supports arrow-key navigation between lines, "
+            "Enter for a newline, Ctrl+S/Ctrl+Enter to submit."
+        ),
+    )
+
+
+class AskUserParams(BaseModel):
+    questions: list[AskUserQuestion] = Field(
+        ...,
+        min_length=1,
+        max_length=MAX_QUESTIONS,
+        description=(
+            f"One or more questions to ask, in order (max {MAX_QUESTIONS} per call — "
+            "group all clarifying questions into one invocation instead of stacking "
+            "several ask_user calls back-to-back). Each is shown and answered before "
+            "the next appears — like a short interview. Use a single-item list for a "
+            "standalone question."
+        ),
+    )
+    timeout: int | None = Field(
+        default=None,
+        description=(
+            "Auto-dismiss after N ms of inactivity on the current question and "
+            "cancel the rest of the sequence if it times out"
+        ),
+    )
+
+
+AskUserQuestion.model_rebuild()
+AskUserParams.model_rebuild()
+
+
+class QuestionValidationError(Exception):
+    """Raised when a question sequence fails validation before any UI is shown."""
+
+
+def normalize_options(raw: list[str | AskUserOption] | None) -> list[AskUserOption]:
+    return [AskUserOption(title=o) if isinstance(o, str) else o for o in (raw or [])]
+
+
+def validate_questions(questions: list[AskUserQuestion]) -> None:
+    """Reject malformed questionnaires up front, before rendering any UI.
+
+    Mirrors the guardrails of the reference ask-user-question implementation:
+    bounded option counts, no reserved/duplicate labels, no duplicate questions,
+    and previews restricted to single-select.
+    """
+    if len(questions) > MAX_QUESTIONS:
+        raise QuestionValidationError(
+            f"ask_user supports at most {MAX_QUESTIONS} questions per call; got "
+            f"{len(questions)}. Group them into fewer, related questions."
+        )
+
+    seen_questions: set[str] = set()
+    for q in questions:
+        if q.question in seen_questions:
+            raise QuestionValidationError(f"Duplicate question: {q.question!r}")
+        seen_questions.add(q.question)
+
+        if not q.options:
+            continue
+
+        if not (MIN_OPTIONS <= len(q.options) <= MAX_OPTIONS):
+            raise QuestionValidationError(
+                f"Question {q.question!r} must have between {MIN_OPTIONS} and "
+                f"{MAX_OPTIONS} options when options are provided; got {len(q.options)}."
+            )
+
+        seen_titles: set[str] = set()
+        for opt in q.options:
+            title = opt if isinstance(opt, str) else opt.title
+            preview = None if isinstance(opt, str) else opt.preview
+
+            if len(title) > MAX_LABEL_LENGTH:
+                raise QuestionValidationError(
+                    f"Option title {title!r} exceeds {MAX_LABEL_LENGTH} characters."
+                )
+            if title == FREEFORM_LABEL:
+                raise QuestionValidationError(
+                    f"{FREEFORM_LABEL!r} is reserved for the auto-appended freeform "
+                    "row — do not author it as an option."
+                )
+            if title in seen_titles:
+                raise QuestionValidationError(f"Duplicate option title: {title!r}")
+            seen_titles.add(title)
+
+            if preview and q.allow_multiple:
+                raise QuestionValidationError(
+                    "Option preview is only supported on single-select questions "
+                    f"(question {q.question!r} has allow_multiple=True)."
+                )

tau_coding_agent-0.6.2/tau/builtins/extensions/ask_user/tool.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from component import _AskUserComponent  # type: ignore[import-not-found]
+from schema import (  # type: ignore[import-not-found]
+    AskUserParams,
+    QuestionValidationError,
+    normalize_options,
+    validate_questions,
+)
+
+from tau.tool.render import call_line
+from tau.tool.types import (
+    Tool,
+    ToolContext,
+    ToolExecutionMode,
+    ToolInvocation,
+    ToolKind,
+    ToolResult,
+)
+
+
+def _render_call(args: dict, _streaming: bool = False) -> list[str]:
+    questions = args.get("questions") or []
+    if len(questions) <= 1:
+        label = questions[0].get("question", "") if questions else ""
+    else:
+        label = f"{len(questions)} questions"
+    return call_line("ask_user", label)
+
+
+def _render_result(content: str, opts: Any) -> list[str]:
+    return content.splitlines() or [content]
+
+
+class AskUserTool(Tool):
+    def __init__(self, runtime_ref: Any) -> None:
+        self._runtime_ref = runtime_ref
+        super().__init__(
+            name="ask_user",
+            description=(
+                "Ask the human one or more focused questions and wait for their decision "
+                "before proceeding. Pass multiple questions to run them as a sequence — "
+                "each is shown and answered in turn, like a short interview — instead of "
+                "issuing separate calls. Do not stack multiple ask_user calls back-to-back; "
+                "group all clarifying questions into one invocation. Use for high-impact "
+                "architectural trade-offs, ambiguous or conflicting requirements, or "
+                "assumptions that would materially change the implementation. Each "
+                "question supports single-select, multi-select, and freeform text "
+                "answers, and up to 4 options when options are given. If you recommend a "
+                "specific option, list it first and append \"(Recommended)\" to its "
+                "title. Only available in an interactive TUI session."
+            ),
+            schema=AskUserParams,
+            kind=ToolKind.Read,
+            execution_mode=ToolExecutionMode.Sequential,
+            render_call=_render_call,
+            render_result=_render_result,
+            render_shell="default",
+        )
+
+    async def execute(
+        self,
+        invocation: ToolInvocation,
+        tool_execution_update_callback=None,
+        signal=None,
+        context: ToolContext | None = None,
+    ) -> ToolResult:
+        params = AskUserParams.model_validate(invocation.params)
+
+        try:
+            validate_questions(params.questions)
+        except QuestionValidationError as e:
+            return ToolResult.error(invocation.id, str(e))
+
+        runtime = self._runtime_ref.runtime if self._runtime_ref is not None else None
+        if runtime is None:
+            return ToolResult.error(invocation.id, "ask_user unavailable: runtime not ready")
+
+        from tau.extensions.context import ExtensionContext
+
+        ext_ctx = ExtensionContext.from_runtime(runtime)
+        ui = ext_ctx.ui
+        if ui is None:
+            return ToolResult.error(
+                invocation.id,
+                "ask_user requires an interactive TUI session and is "
+                "unavailable in headless/RPC mode",
+            )
+
+        answers: list[dict] = []
+
+        for question in params.questions:
+            options = normalize_options(question.options)
+            response = await self._ask_one(ui, question, options, params.timeout)
+
+            if response is None:
+                return ToolResult.ok(
+                    invocation.id,
+                    self._format_answers(answers, cancelled_at=question.question),
+                    metadata={
+                        "cancelled": True,
+                        "answers": answers,
+                        "cancelled_question": question.question,
+                    },
+                )
+
+            if response["kind"] == "freeform":
+                content = response["text"]
+            else:
+                content = ", ".join(response["selections"])
+
+            answers.append(
+                {"question": question.question, "response": content, "raw": response}
+            )
+
+        return ToolResult.ok(
+            invocation.id,
+            self._format_answers(answers),
+            metadata={"cancelled": False, "answers": answers},
+        )
+
+    async def _ask_one(
+        self,
+        ui: Any,
+        question: Any,
+        options: Any,
+        timeout: int | None,
+    ) -> dict | None:
+        loop = asyncio.get_running_loop()
+        fut: asyncio.Future[dict | None] = loop.create_future()
+        timeout_task_ref: list[asyncio.Task | None] = [None]
+
+        def _on_done(value: dict | None) -> None:
+            t = timeout_task_ref[0]
+            if t is not None and not t.done():
+                t.cancel()
+            if not fut.done():
+                fut.set_result(value)
+
+        def _factory(_tui, _theme, _kb, done):
+            component = _AskUserComponent(
+                question=question.question,
+                context=question.context,
+                options=options,
+                allow_multiple=question.allow_multiple,
+                allow_freeform=question.allow_freeform,
+                multiline=question.multiline,
+                on_done=lambda v: (_on_done(v), done(v)),
+            )
+            if timeout:
+                timeout_ms = timeout
+
+                async def _auto_dismiss() -> None:
+                    await asyncio.sleep(timeout_ms / 1000)
+                    _on_done(None)
+                    done(None)
+
+                timeout_task_ref[0] = asyncio.ensure_future(_auto_dismiss())
+            return component
+
+        await ui.custom_inline(_factory, kind="ask_user")
+        return await fut
+
+    @staticmethod
+    def _format_answers(answers: list[dict], cancelled_at: str | None = None) -> str:
+        if not answers and cancelled_at is None:
+            return "The user cancelled the question without answering."
+
+        lines: list[str] = []
+        for i, item in enumerate(answers, start=1):
+            lines.append(f"Q{i}: {item['question']}")
+            lines.append(f"A{i}: {item['response']}")
+            lines.append("")
+
+        if cancelled_at is not None:
+            lines.append(f"(Cancelled before answering: {cancelled_at})")
+
+        return "\n".join(lines).rstrip()