ouyangbo/EvoScientist-Multi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
01845f43110ad444b7e2a61b920effdf7e719029
EvoScientist-Multi/EvoScientist/cli/tui_interactive.py
T
dinos 01845f4311 refactor: route middleware display events through an injected event sink (#343) 
* chore: add pytest-asyncio in auto mode

* test: migrate channel and stream tests to native async

Convert run_async() wrapper tests to plain 'async def test_*' under
pytest-asyncio auto mode. collect_events() in stream_v3_fakes becomes a
coroutine awaited at every call site.

* test: migrate command and model/middleware tests to native async

Convert run_async() wrappers (import, alias, and fixture forms) to plain
'async def test_*'. Multi-call tests merge onto one loop as sequential
awaits; none asserted on loop identity.

* test: migrate TUI, notifier, gateway, and session tests to native async

TUI/notifier/gateway files convert run_async wrappers to plain async
tests. test_sessions.py's unittest.TestCase classes move to
unittest.IsolatedAsyncioTestCase (pytest-asyncio does not await async
methods on plain TestCase; converting blindly would have made ~70 tests
silently vacuous). Its setUpClass keeps a one-shot asyncio.run() since
IsolatedAsyncioTestCase has no async class-level hook. TestLoadingWidget
in test_tui_widgets.py drops its TestCase base for the same reason.

* test: replace direct asyncio.run() calls with native async tests

Convert tests that called asyncio.run() (directly or via a local _run
helper) to plain 'async def test_*'; delete the local helpers.

* test: drop undeclared anyio markers and delete run_async helper

The @pytest.mark.anyio tests relied on anyio being a transitive dep of
httpx; auto-mode pytest-asyncio collects them natively. run_async() and
its fixture are unreferenced after the migration, so remove them —
pytest-asyncio's per-test loop teardown covers the pending-task
cancellation the helper existed for (verified: full suite runs with no
'Event loop is closed' errors or destroyed-task warnings).

* test: add autouse fixture for watcher cleanup

* refactor: remove redundant hasattr calls

* refactor: add typed middleware event sink and thread through assembly

Add MiddlewareEventSink protocol + NoOpSink in middleware/events.py
with a documented any-thread non-blocking contract (contract test uses a
deliberately-slow fake sink). Thread an optional `events` parameter
through create_cli_agent -> _get_default_middleware -> tool selector /
model fallback constructors; subagent stacks are always forced to
NoOpSink.

* refactor: inject a notifier port into async-watcher and background middleware

Add public pre_cancel_watcher() and enqueue_task_notification() to
cli/async_notifier.py and a small NotifierPort protocol
(middleware/notifier.py) that the module satisfies structurally.
AsyncWatcherMiddleware and BackgroundExecutionMiddleware now receive the
port by constructor injection at the composition root, deleting the lazy
'from ..cli import async_notifier' imports and the private
_watcher_by_thread / _enqueue pokes.

* refactor: invert tool-selection ownership onto a frontend event sink

The adaptive tool selector now reports on_tool_selection_started /
on_tool_selection / on_tool_selection_ended to the injected sink instead
of writing four process-global module variables. The frontend sink
(stream/sink.py FrontendEventSink) owns the selected/total/active state
with consume-once + dedup-vs-last-emitted semantics;
stream/tool_selection.py reads that sink object (a ToolSelectionView)
rather than reaching into tool_selector's globals.

Deleted: the 4 module globals, the cross-module mutations in
tool_selection.py, the track_stream_selection flag, the now-vestigial
_ToolSelectionTrackerMiddleware, reset_tool_selection_state_for_tests,
and the autouse conftest fixture. The sink is threaded from the two
interactive frontends through create_runtime_gateways ->
LocalGraphGateway (read side) and _load_agent -> create_cli_agent (write
side); subagent / headless stacks get NoOpSink.

* refactor: route model-fallback narration through the injected event sink

Delete the _ui_emit_fn / set_ui_emit module global and the
..stream.console import from model_fallback.py. The fallback middleware
now reports through its injected sink: the fallback transition via the
structured on_model_fallback (the frontend formats the '-> Falling back
to ...' line), and the surrounding narration (primary-failure header,
per-attempt outcome, exhaustion, non-fallbackable rejection) via
emit_fallback_notice, preserving the exact user-facing text. The TUI
binds its _append_system as the sink's fallback display where it used to
call set_ui_emit (cleared on exit); the Rich CLI's sink prints to the
console. _try_fallbacks / _guard_and_fallback take the sink.

* refactor: declare events on the GraphGateway protocol

Both gateway implementations now carry an explicit events attribute
(LangGraphServerGateway holds None — no frontend renders middleware
events across the HTTP boundary), so the four call sites use plain
attribute access instead of getattr probing an implicit contract.

* refactor: bind fallback display via the closure-scoped concrete sink

The App methods used gateway.events (typed as the read-side view) and
hasattr-probed for the concrete FrontendEventSink API. The enclosing
factory creates that sink two hundred lines up — close over it directly:
no probing, fully typed, and it becomes a constructor parameter
naturally when the App class is hoisted out of the factory.

* fix: end tool selection before fallback handler

* fix: keep fallback display errors non-fatal

* fix: preserve selector suppression for default streams

* fix: restore fallback notice console display

* refactor: consolidate fallback narration events

* refactor: clean middleware event sink plumbing

* fix: type gateway session events

* refactor: make all event protocols runtime-checkable

MiddlewareEventSink already carried @runtime_checkable (the stream
binding guard isinstance-checks it); ToolSelectionView and SessionEvents
now match, so mirroring that pattern against any of the three protocols
works instead of raising TypeError.

* fix(cli): close QuickJS workers after one-shot failures

* fix(cli): honor no-thinking in final output

* fix(channels): report failed startup accurately

* fix(channels): make Telegram cleanup idempotent

* fix(tui): skip command sync during exit

* fix(channels): preserve startup state during retries

* refactor(channels): share pending startup status

* refactor(cli): expose channel startup snapshot

* fix(tui): move channel startup off event loop

* test(channels): release retry gate on assertion failure

---------

Co-authored-by: Xi Zhang <106144707+X-iZhang@users.noreply.github.com>
2026-07-14 22:34:17 +00:00

3465 lines
152 KiB
Python
Raw Blame History

"""Full-screen Textual interactive TUI for EvoScientist.
Widget-based rendering: each message/tool/sub-agent is an independent widget
mounted into a VerticalScroll container. No timer-based Group rebuilds.
"""
from __future__ import annotations
import asyncio
import logging
import queue
import random
import sys
import threading
from collections.abc import Callable
from dataclasses import dataclass
from datetime import datetime
from typing import TYPE_CHECKING, Any, ClassVar
from rich.console import Group
from rich.text import Text
import EvoScientist.cli.channel as _ch_mod
from EvoScientist.cli.widgets.thread_selector import ThreadPickerWidget
from ..commands import Command, CommandContext
from ..commands import manager as cmd_manager
from ..gateway import (
GraphGateway,
GraphTarget,
RunRequest,
RuntimeGateways,
create_runtime_gateways,
)
from ..paths import DATA_DIR
from ..sessions import get_checkpointer
from ..stream.state import ResearchPhase, StreamState
from ._agent_loader import BackgroundAgentLoader, MCPProgressTracker
from ._constants import (
DANGEROUS_BANNER_LABEL,
DANGEROUS_BANNER_MESSAGE,
LOGO_GRADIENT,
LOGO_LINES,
WELCOME_SLOGANS,
build_metadata,
)
from .async_notifier import (
AsyncTasksState,
consume_notifications,
has_pending_notifications,
read_async_tasks_from_gateway,
)
from .channel import (
ChannelMessage,
_auto_start_channel,
_channels_is_running,
_channels_stop,
_message_queue,
_set_channel_response,
dispatch_channel_slash_command,
get_channel_startup_results,
)
from .file_mentions import complete_file_mention, resolve_file_mentions
from .history_suggester import HistorySuggester
from .status_bar import (
STATUS_BAR_BG,
STATUS_DIM,
STATUS_GOOD,
STATUS_HINT_BUSY,
STATUS_HINT_IDLE,
STATUS_HINT_WRITING,
apply_assistant_text_to_snapshot,
apply_user_text_to_snapshot,
build_session_status_snapshot,
build_status_text,
format_duration_compact,
make_empty_status_snapshot,
make_usage_status_snapshot,
)
_channel_logger = logging.getLogger(__name__)
if TYPE_CHECKING:
from langgraph.graph.state import CompiledStateGraph
def _shorten_path(path: str) -> str:
"""Shorten absolute path to a cwd-relative form (consistent with Rich CLI)."""
if not path:
return path
from .agent import _shorten_path as _sp
return _sp(path)
async def _auto_start_channel_in_worker(
agent: Any,
thread_id: str,
config: Any,
*,
send_thinking: bool,
runtime: Any,
stop_requested: threading.Event,
) -> list[tuple[str, bool, str]]:
"""Run blocking channel startup without occupying the TUI event loop."""
def _start() -> list[tuple[str, bool, str]]:
try:
return _auto_start_channel(
agent,
thread_id,
config,
send_thinking=send_thinking,
runtime=runtime,
)
finally:
if stop_requested.is_set():
_channels_stop(runtime=runtime)
worker = asyncio.create_task(asyncio.to_thread(_start))
try:
return await asyncio.shield(worker)
except asyncio.CancelledError:
stop_requested.set()
try:
await worker
except Exception:
_channel_logger.debug(
"Channel startup worker failed during cancellation",
exc_info=True,
)
raise
def _build_welcome_banner(
*,
thread_id: str,
workspace_dir: str | None,
mode: str | None,
model: str | None,
provider: str | None,
ui_backend: str | None = None,
channels: list[tuple[str, bool, str]] | None = None,
) -> Any:
"""Build CLI-matching welcome banner with logo, info line, and channels.
Args:
channels: List of (name, ok, detail) tuples for the channels panel.
"""
banner = Text()
for line, color in zip(LOGO_LINES, LOGO_GRADIENT, strict=False):
banner.append(f"{line}\n", style=f"bold {color}")
# Info line — matches CLI print_banner format
info = Text()
parts: list[tuple[str, str]] = []
if model:
parts.append(("Model: ", model))
if provider:
parts.append(("Provider: ", provider))
if mode:
parts.append(("Mode: ", mode))
if ui_backend:
parts.append(("UI: ", ui_backend))
if parts:
info.append(" ", style="dim")
for i, (label, value) in enumerate(parts):
if i > 0:
info.append(" ", style="dim")
info.append(label, style="dim")
info.append(value, style="magenta")
# Directory line
import os
effective_dir = workspace_dir or os.getcwd()
home = os.path.expanduser("~")
dir_display = (
effective_dir.replace(home, "~", 1)
if effective_dir.startswith(home)
else effective_dir
)
info.append("\n ", style="dim")
info.append("Directory: ", style="dim")
info.append(dir_display, style="magenta")
_nl_key = "Option+Enter" if sys.platform == "darwin" else "Ctrl+J"
info.append("\n Enter ", style="#ffe082")
info.append("send", style="#ffe082 bold")
info.append(f" \u2022 {_nl_key} ", style="#ffe082")
info.append("newline", style="#ffe082 bold")
info.append(" \u2022 Type ", style="#ffe082")
info.append("/", style="#ffe082 bold")
info.append(" for commands", style="#ffe082")
info.append(" \u2022 ", style="#ffe082")
info.append("@ files", style="#ffe082 bold")
info.append(" \u2022 Ctrl+C ", style="#ffe082")
info.append("interrupt", style="#ffe082 bold")
try:
from ..config import get_effective_config
if get_effective_config().dangerous_mode:
info.append(
f"\n \u26a0 {DANGEROUS_BANNER_LABEL}", style="bold white on red"
)
info.append(f" {DANGEROUS_BANNER_MESSAGE}", style="bold red")
except Exception:
pass
banner.append_text(info)
slogan = Text(f"\n {random.choice(WELCOME_SLOGANS)}", style="dim italic")
# Channels panel
if channels:
from rich.panel import Panel
lines: list[Text] = []
all_ok = True
for name, ok, detail in channels:
line = Text()
if ok:
line.append("\u25cf ", style="green")
line.append(name, style="bold")
else:
line.append("\u25cb ", style="dim")
line.append(name, style="bold dim")
all_ok = False
if detail:
line.append(f" {detail}", style="dim")
lines.append(line)
body = Text("\n").join(lines)
border = "green" if all_ok else "dim"
panel = Panel(
body, title="[bold]Channels[/bold]", border_style=border, expand=False
)
return Group(banner, Text(""), panel, slogan)
# No channels — append slogan directly to banner
banner.append_text(slogan)
return banner
def _is_final_response(state: StreamState) -> bool:
"""Check if all tools are done and no sub-agents are active."""
n_done, n_visible = state.visible_tool_counts()
has_pending = n_visible > n_done
any_active_sa = any(sa.is_active for sa in state.subagents)
return not has_pending and not any_active_sa and not state.is_processing
_SUMMARY_CONTINUATION_EVENTS = {
"summarization_start",
"summarization",
"usage_stats",
}
async def _sync_tui_command_completion(
app: Any,
ctx: CommandContext,
original_agent: Any,
cmd: Command,
) -> None:
"""Adopt successful command-side state changes back into the TUI app."""
if app._exiting:
return
agent_swapped = ctx.agent is not None and ctx.agent is not original_agent
if agent_swapped:
from ..EvoScientist import _ensure_config
app._agent_loader.adopt(ctx.agent)
cfg = _ensure_config()
update_model = getattr(app, "update_status_after_model_change", None)
if callable(update_model):
update_model(cfg.model, cfg.provider)
# Rebind the runtime whenever the agent OR thread_id may have moved
# — ``/new`` and ``/resume`` rotate ``app._conversation_tid``
# without swapping the agent, and the bus expects both to stay in
# sync (matches the serve-mode hook contract).
if _channels_is_running():
runtime_agent = ctx.agent if ctx.agent is not None else app._agent_loader.agent
if runtime_agent is not None:
app._channel_runtime.bind(runtime_agent, app._conversation_tid)
await app._refresh_status_snapshot(reset_streaming_text=True)
def _should_finalize_active_summarization(event_type: str) -> bool:
"""Return whether an active summary panel should stop for this event."""
return bool(event_type) and event_type not in _SUMMARY_CONTINUATION_EVENTS
def _response_after_narration(response_text: str, narrated_response_end: int) -> str:
"""Return the response suffix that has not already been shown inline."""
return response_text[max(0, narrated_response_end) :]
def _strip_trailing_placeholder_ellipsis(text: str) -> str:
"""Remove the standalone streaming placeholder suffix from final TUI text."""
clean = text.strip()
while clean.endswith("\n...") or clean.rstrip() == "...":
clean = clean.rstrip().removesuffix("...").rstrip()
return clean
def _stopped_response_after_narration(
previous_text: str,
narrated_response_end: int,
) -> tuple[str, str, str]:
"""Return display-current, display-stopped, and full stopped response text."""
from ..stream.display import build_stopped_response_text
display_previous = _response_after_narration(previous_text, narrated_response_end)
display_current, display_stopped = build_stopped_response_text(display_previous)
_, full_stopped = build_stopped_response_text(previous_text)
return display_current, display_stopped, full_stopped
def run_textual_interactive(
*,
show_thinking: bool,
channel_send_thinking: bool = True,
workspace_dir: str | None,
workspace_fixed: bool,
mode: str | None,
model: str | None,
provider: str | None,
run_name: str | None,
thread_id: str | None,
load_agent: Callable[..., Any],
create_session_workspace: Callable[[str | None], str],
config: Any | None = None,
) -> None:
"""Run full-screen Textual interactive chat loop."""
if config is None:
from ..config import get_effective_config
config = get_effective_config()
# One frontend event sink for the whole TUI session — injected into the
# agent's middleware (write side) and the local gateway's streaming path
# (read side). The fallback-notice display is bound to the App's
# _append_system once the App exists (on_mount); tool-selection needs no
# display hook (its widget is mounted from the stream event).
from ..stream.sink import SessionEventSink
event_sink = SessionEventSink()
runtime_gateways = create_runtime_gateways(events=event_sink)
graph_gateway = runtime_gateways.graph_gateway
try:
from textual.app import App, ComposeResult
from textual.binding import Binding
from textual.containers import Container, Horizontal, VerticalScroll
from textual.events import MouseUp
from textual.widget import Widget
from textual.widgets import Static
from .clipboard import copy_selection_to_clipboard, get_clipboard_text
from .widgets import (
AssistantMessage,
CompactingWidget,
LoadingWidget,
MCPLoaderWidget,
SubAgentWidget,
SummarizationWidget,
SystemMessage,
ThinkingWidget,
TodoWidget,
ToolCallWidget,
UsageWidget,
UserMessage,
)
from .widgets.chat_input import ChatTextArea
except Exception as e: # pragma: no cover - runtime fallback path
raise RuntimeError(
"Textual TUI backend requires 'textual'. Run: pip install textual"
) from e
class EvoTextualInteractiveApp(App[None]): # type: ignore[type-arg]
"""Deep-Agents-style full-screen TUI with independent widget rendering."""
@property
def supports_interactive(self) -> bool:
return True
CSS = """
Screen {
layout: vertical;
background: #16161a;
color: #d1d5db;
}
#chat {
height: 1fr;
padding: 1 2;
background: #16161a;
}
#welcome {
height: auto;
margin-bottom: 1;
}
#input-shell {
height: auto;
padding: 0 2 0 2;
background: #16161a;
}
#input-row {
height: auto;
min-height: 3;
max-height: 10;
border: solid #0284c7;
background: #1e1f26;
padding: 0 1;
}
#input-cursor {
width: 2;
content-align: center middle;
color: #0284c7;
text-style: bold;
}
#prompt {
width: 1fr;
min-height: 1;
max-height: 8;
border: none;
background: transparent;
color: #e5e7eb;
}
#prompt:focus {
border: none;
}
#queued-message {
display: none;
height: auto;
background: #1e1f26;
padding: 0 2;
color: #9ca3af;
}
#completions {
display: none;
height: auto;
max-height: 15;
background: #1e1f26;
padding: 0 1;
border-bottom: solid #0284c7;
}
#status {
height: 1;
min-height: 1;
background: #171a20;
color: #cbd5e1;
padding: 0 1;
}
"""
BINDINGS: ClassVar[list[Binding]] = [
Binding("ctrl+c", "request_quit", "Quit", show=False, priority=True),
Binding("ctrl+v", "paste_clipboard", "Paste", show=False),
Binding("tab", "tab_complete", show=False, priority=True),
Binding("up", "edit_queued", show=False, priority=True),
Binding("down", "down_delegate", show=False, priority=True),
Binding("escape", "cancel_queued", show=False, priority=True),
]
def __init__(
self,
*,
thread_id_value: str,
workspace: str | None,
checkpointer: Any,
runtime_gateways: RuntimeGateways,
channel_send_thinking_value: bool = True,
resumed: bool = False,
resume_warning: str = "",
) -> None:
super().__init__()
self._progress_tracker = MCPProgressTracker()
self._agent_loader = BackgroundAgentLoader(
load_agent,
on_progress=self._on_mcp_progress,
on_success=self._on_agent_load_success,
on_failure=self._on_agent_load_failure,
)
self._mcp_loader_widget: Any = None
self._conversation_tid = thread_id_value
self._workspace_dir = workspace
self._checkpointer = checkpointer
self._runtime_gateways = runtime_gateways
self._channel_send_thinking = channel_send_thinking_value
self._resumed = resumed
self._resume_warning = resume_warning
self._channel_timer: Any = None
self._channel_start_results: list[tuple[str, bool, str]] = []
self._channel_start_stop = threading.Event()
self._busy = False
self._notification_consuming: bool = (
False # prevent overlapping consume coroutines
)
self._run_task: Any = None # asyncio.Task for current _run_turn
self._queued_messages: list[
str
] = [] # queued messages to send after current turn
self._comp_items: list = []
self._comp_index: int = -1
self._comp_base: str = ""
self._hitl_auto_approve: bool = False
self._approval_future: asyncio.Future | None = None
self._ask_user_future: asyncio.Future | None = None
self._picker_future: asyncio.Future | None = None
self._browser_future: asyncio.Future | None = None
self._mcp_browser_future: asyncio.Future | None = None
self._model_picker_future: asyncio.Future | None = None
self._history_suggester = HistorySuggester(DATA_DIR / "history")
self._history_index: int = -1 # -1 = not browsing history
self._history_saved_input: str = "" # saved current input before browsing
self._background_tasks: set[asyncio.Task] = set()
from ..commands.base import ChannelRuntime
self._channel_runtime = ChannelRuntime()
self._quit_pending: bool = False
self._exiting: bool = False
self._current_model: str | None = model
self._current_provider: str | None = provider
self._status_started_at = datetime.now()
self._status_base_snapshot = make_empty_status_snapshot(self._current_model)
self._status_snapshot = self._status_base_snapshot
self._status_streaming_text = ""
self._status_last_input_tokens: int | None = None
self._status_phase: ResearchPhase = ResearchPhase.IDLE
self._turn_started_at: datetime | None = None
self._compacting_widget: CompactingWidget | None = None
self._chat_following: bool = True
self._new_content_below: bool = False
# ── Background agent / MCP loading ───────────────────
def _on_mcp_progress(self, event: str, server: str, detail: str) -> None:
"""Bridge worker-thread progress events to the Textual loop."""
if event not in {"start", "success", "error"}:
return
try:
self.call_from_thread(self._apply_mcp_progress, event, server, detail)
except Exception:
pass
def _apply_mcp_progress(self, event: str, server: str, detail: str) -> None:
"""Update tracker + widget on the Textual thread."""
state = self._progress_tracker.record(event, server, detail)
if state is None:
return
widget = self._mcp_loader_widget
if widget is None or widget.dismissed:
self._mcp_loader_widget = None
return
widget.update_server(server, state, detail)
def _on_agent_load_success(self, agent: Any) -> None:
if _channels_is_running():
self._channel_runtime.bind(agent, self._conversation_tid)
self._finish_loader_widget()
self._render_status()
def _on_agent_load_failure(self, exc: BaseException) -> None:
self._append_system(f"Agent failed to load: {exc}", style="red")
self._finish_loader_widget()
def _start_background_agent_load(self, workspace: str | None) -> None:
self._progress_tracker.prime()
self._mount_mcp_loader_widget()
self._agent_loader.start(
workspace_dir=workspace,
checkpointer=self._checkpointer,
events=self._runtime_gateways.graph_gateway.events,
)
def _mount_mcp_loader_widget(self) -> None:
if not self._progress_tracker.progress:
return
if self._mcp_loader_widget is not None:
try:
self._mcp_loader_widget.remove()
except Exception:
pass
self._mcp_loader_widget = None
widget = MCPLoaderWidget(list(self._progress_tracker.progress.keys()))
try:
shell = self.query_one("#input-shell", Container)
children = list(shell.children)
if children:
shell.mount(widget, before=children[0])
else:
shell.mount(widget)
except Exception:
# Compose hasn't happened yet — the mount will be retried
# from ``on_mount`` once the DOM is ready.
return
self._mcp_loader_widget = widget
def _finish_loader_widget(self) -> None:
"""Call ``mark_finished`` and clear the ref if self-dismissed."""
widget = self._mcp_loader_widget
if widget is None:
return
try:
widget.mark_finished()
except Exception:
pass
if widget.dismissed:
self._mcp_loader_widget = None
async def _await_agent_ready(self) -> CompiledStateGraph:
"""Await the agent load, auto-retrying on cold-start or failure."""
if self._agent_loader.needs_restart:
self._start_background_agent_load(self._workspace_dir)
return await self._agent_loader.await_ready()
def _graph_gateway(self) -> GraphGateway:
return self._runtime_gateways.graph_gateway
# ── CommandUI implementation ─────────────────────────
def append_system(self, text: str, style: str = "dim") -> None:
self._append_system(text, style)
def mount_renderable(self, renderable: Any) -> None:
self._mount_renderable(renderable)
async def start_compacting_indicator(self) -> None:
await self._start_compacting_indicator()
async def stop_compacting_indicator(self) -> None:
await self._stop_compacting_indicator()
async def wait_for_thread_pick(
self, threads: list[dict], current_thread: str, title: str
) -> str | None:
from .widgets.thread_selector import ThreadPickerWidget
container = self.query_one("#chat", VerticalScroll)
picker = ThreadPickerWidget(
threads,
current_thread=current_thread,
title=title,
)
await container.mount(picker)
self._anchor_chat(container)
picker.focus()
return await self._wait_for_thread_pick(picker)
async def wait_for_skill_browse(
self, index: list[dict], installed_names: set[str], pre_filter_tag: str
) -> list[str] | None:
from .widgets.skill_browser import SkillBrowserWidget
container = self.query_one("#chat", VerticalScroll)
browser = SkillBrowserWidget(
index,
installed_names,
pre_filter_tag=pre_filter_tag,
)
await container.mount(browser)
self._anchor_chat(container)
browser.focus()
return await self._wait_for_skill_browse(browser)
async def wait_for_mcp_browse(
self, servers: list, installed_names: set[str], pre_filter_tag: str
) -> list | None:
from .widgets.mcp_browser import MCPBrowserWidget
container = self.query_one("#chat", VerticalScroll)
browser = MCPBrowserWidget(
servers,
installed_names,
pre_filter_tag=pre_filter_tag,
)
await container.mount(browser)
self._anchor_chat(container)
browser.focus()
return await self._wait_for_mcp_browse(browser)
async def wait_for_model_pick(
self,
entries: list[tuple[str, str, str]],
current_model: str | None,
current_provider: str | None,
) -> tuple[str, str] | None:
from .widgets.model_picker import ModelPickerWidget
container = self.query_one("#chat", VerticalScroll)
picker = ModelPickerWidget(
entries,
current_model=current_model,
current_provider=current_provider,
)
await container.mount(picker)
self._anchor_chat(container)
picker.focus()
return await self._wait_for_model_pick(picker)
def clear_chat(self) -> None:
container = self.query_one("#chat", VerticalScroll)
welcome = self.query_one("#welcome", Static)
for child in list(container.children):
if child is not welcome:
child.remove()
# Issue #301: unconditionally release the anchor and pin to the
# top after wiping. The children removed above are laid out
# asynchronously, so a ``max_scroll_y`` check at this moment is
# stale — relying on it (via ``_anchor_chat``) can re-engage the
# anchor and let Textual's compositor push ``scroll_y`` negative
# once the new (smaller) content lays out. Always reset.
self._release_anchor_and_pin_top(container)
self._chat_following = True
self._new_content_below = False
def request_quit(self) -> None:
self.action_request_quit()
async def start_new_session(self) -> None:
# Clear all widgets except #welcome
self.clear_chat()
_ch_mod.forget_channel_origin(self._conversation_tid)
if not workspace_fixed:
self._workspace_dir = create_session_workspace(run_name)
self._conversation_tid = (
await self._runtime_gateways.graph_gateway.create_thread(
GraphTarget(workspace_dir=self._workspace_dir)
)
)
# Background reload: next user message awaits it.
self._start_background_agent_load(self._workspace_dir)
self._status_started_at = datetime.now()
self._status_base_snapshot = make_empty_status_snapshot(self._current_model)
self._status_snapshot = self._status_base_snapshot
self._status_streaming_text = ""
self._status_last_input_tokens = None
self._render_welcome()
self._render_status()
refresh_task = asyncio.create_task(self._refresh_status_snapshot())
self._background_tasks.add(refresh_task)
refresh_task.add_done_callback(self._background_tasks.discard)
self.append_system(f"New session: {self._conversation_tid}", style="green")
self._append_pending_skill_proposals_notice()
async def handle_session_resume(
self, thread_id: str, workspace_dir: str | None = None
) -> None:
if workspace_dir:
# Mirror the Rich CLI fix: when a /resume restores a thread
# whose workspace differs from the one the langgraph dev
# subprocess was launched with, background workers and
# deployed sub-agents would otherwise keep operating on the
# previous workspace. Sync the subprocess to the new workspace;
# the manager auto-detects the change and restarts when needed.
# Run in a worker thread so the Textual event loop keeps
# refreshing the UI during the up-to-60s wait, and show a live
# timer widget (like /compact) so the user sees progress
# instead of a frozen static line.
#
# ``self._workspace_dir`` is mutated AFTER mismatch checks so
# WorkspaceMismatchError leaves the session pointing at the
# existing workspace. Other sync failures resume locally in
# the TUI while background workers may be unavailable.
from ..langgraph_dev.manager import WorkspaceMismatchError
from .commands import _sync_background_agent_server_workspace
from .widgets.workspace_sync_widget import WorkspaceSyncWidget
sync_widget = WorkspaceSyncWidget()
container = self.query_one("#chat", VerticalScroll)
await container.mount(sync_widget)
container.scroll_end(animate=False)
try:
await _sync_background_agent_server_workspace(
config,
workspace_dir=workspace_dir,
)
except WorkspaceMismatchError as exc:
# Another EvoSci process owns the langgraph dev for a
# different workspace. Abort the resume without mutating
# session state. Raise so command UIs, including channel
# UI, report failure instead of continuing with
# success/history output.
raise RuntimeError(str(exc)) from exc
except Exception:
_channel_logger.warning(
"Failed to sync background agent server for resumed "
"workspace %s; continuing resume in degraded mode",
workspace_dir,
exc_info=True,
)
self.append_system(
"Background agent server sync failed; resumed local "
"session, but async subagents and EvoMemory workers "
"may be unavailable.",
style="yellow",
)
finally:
await sync_widget.cleanup()
self._workspace_dir = workspace_dir
if thread_id != self._conversation_tid:
# Only drop the origin on a real thread change — resuming the
# already-active thread must keep its live origin so a later
# async-notifier turn still forwards to the channel.
_ch_mod.forget_channel_origin(self._conversation_tid)
self._conversation_tid = thread_id
# Background reload: history renders immediately; next turn awaits.
self._start_background_agent_load(self._workspace_dir)
self._status_started_at = datetime.now()
self._status_base_snapshot = make_empty_status_snapshot(self._current_model)
self._status_snapshot = self._status_base_snapshot
self._status_streaming_text = ""
self._status_last_input_tokens = None
self._render_welcome()
await self._refresh_status_snapshot()
self._render_status()
self.append_system(f"Resumed session: {thread_id}", style="green")
await self._render_history(thread_id)
self._append_pending_skill_proposals_notice()
async def flush(self) -> None:
"""No-op for TUI, messages are already delivered incrementally."""
pass
# ── Layout ─────────────────────────────────────────────
def compose(self) -> ComposeResult:
with VerticalScroll(id="chat"):
yield Static("", id="welcome")
# Widgets are mounted directly here by _stream_with_widgets,
# _append_system, _mount_renderable, etc.
with Container(id="input-shell"):
yield Static("", id="queued-message")
yield Static("", id="completions")
with Horizontal(id="input-row"):
yield Static(">", id="input-cursor")
yield ChatTextArea(
placeholder="Type message (/ for commands)",
id="prompt",
)
yield Static("", id="status")
def on_mount(self) -> None:
# Bind the session sink's fallback-notice display so model-fallback
# messages appear as SystemMessage widgets in the chat container.
# ``event_sink`` is the concrete SessionEventSink created by the
# enclosing factory — the same instance the gateway carries.
event_sink.set_fallback_display(
lambda text, style: self._append_system(text, style)
)
self._render_welcome()
self._render_status()
self.set_interval(1.0, self._render_status)
# Kick off agent construction in the background so the TUI
# appears instantly; MCP progress shows up in the status bar.
if self._agent_loader.agent is None and self._agent_loader.task is None:
self._start_background_agent_load(self._workspace_dir)
refresh_task = asyncio.create_task(self._refresh_status_snapshot())
self._background_tasks.add(refresh_task)
refresh_task.add_done_callback(self._background_tasks.discard)
prompt = self.query_one("#prompt", ChatTextArea)
prompt.before_submit = self._handle_completion_enter
prompt.focus()
# Show resume status
if self._resume_warning:
self._append_system(self._resume_warning, style="yellow")
self._append_pending_skill_proposals_notice()
elif self._resumed:
self._append_system(
f"Resumed session: {self._conversation_tid}",
style="green",
)
self.call_later(
lambda: asyncio.ensure_future(
self._render_history_then_pending_notice(self._conversation_tid)
)
)
else:
self._append_pending_skill_proposals_notice()
# Startup notifications
self.notify(
"EvoScientist is your research buddy.\n"
"Tell it about your taste before cooking some meal!",
severity="warning",
timeout=10,
)
self.run_worker(
self._check_for_updates, exclusive=True, group="update-check"
)
# Auto-start channels — needs the agent, so defer to after load
async def _deferred_start_channels():
try:
await self._await_agent_ready()
except Exception:
_channel_logger.debug(
"Skipping channel auto-start because agent load failed",
exc_info=True,
)
return
await self._start_channels()
ch_task = asyncio.create_task(_deferred_start_channels())
self._background_tasks.add(ch_task)
ch_task.add_done_callback(self._background_tasks.discard)
# ── Update check ──────────────────────────────────────
async def _check_for_updates(self) -> None:
"""Check PyPI for a newer EvoScientist version and notify."""
try:
from ..update_check import _installed_version, is_update_available
available, latest = await asyncio.to_thread(is_update_available)
if available:
current = _installed_version()
self.notify(
f"Update available: v{latest} (current: v{current}).\n"
"Run: uv tool upgrade EvoScientist",
severity="information",
timeout=15,
)
except Exception:
_channel_logger.debug("Background update check failed", exc_info=True)
# ── Channel integration ────────────────────────────────
async def _start_channels(self) -> None:
"""Auto-start channels if enabled in config."""
try:
from ..config import load_config
cfg = await asyncio.to_thread(load_config)
if cfg and cfg.channel_enabled and not _channels_is_running():
results = await _auto_start_channel_in_worker(
self._agent_loader.agent,
self._conversation_tid,
cfg,
send_thinking=self._channel_send_thinking,
runtime=self._channel_runtime,
stop_requested=self._channel_start_stop,
)
if self._exiting:
return
current_agent = self._agent_loader.agent
if current_agent is not None and _channels_is_running():
self._channel_runtime.bind(
current_agent,
self._conversation_tid,
)
self._channel_start_results = results
self._render_welcome()
except asyncio.CancelledError:
self._channel_start_stop.set()
raise
except Exception as e:
_channel_logger.debug(f"Channel auto-start failed: {e}")
finally:
if (
not self._exiting
and not self._channel_start_stop.is_set()
and self._channel_timer is None
):
self._channel_timer = self.set_interval(
0.1,
self._poll_channel_queue,
)
def _poll_channel_queue(self) -> None:
"""Poll the channel + notification queues (every 100ms)."""
try:
msg = _message_queue.get_nowait()
except queue.Empty:
msg = None
if msg is not None:
if self._busy:
_message_queue.put(msg)
return
self.call_later(
lambda m=msg: asyncio.ensure_future(
self._process_channel_message(m)
)
)
return
# Notification path (only when idle and NOT already consuming).
# _notification_consuming is set synchronously at the schedule point
# so that the next poll tick cannot schedule a second consumer before
# the first one has a chance to run (fixes overlapping-turn bug).
if (
has_pending_notifications(self._conversation_tid)
and not self._busy
and not self._notification_consuming
):
self._notification_consuming = True
self.call_later(
lambda: asyncio.ensure_future(self._consume_notifications_tui())
)
async def _consume_notifications_tui(self) -> None:
"""Drain the notification queue and inject a synthetic agent turn.
Wraps the consume call in a swallowing try/except (Fix #4) so an
exception inside dedup/inject doesn't bubble out of the
``asyncio.ensure_future(...)`` scheduled by ``_poll_channel_queue``
and silently kill notification + channel dispatch.
"""
target_tid = self._conversation_tid
try:
try:
await consume_notifications(
run_message=lambda text, notifs: self._inject_notification_tui(
text, notifs, target_thread_id=target_tid
),
read_async_tasks_state=lambda: self._read_async_tasks_tui(
target_tid
),
current_thread_id=target_tid,
)
except Exception:
import logging
logging.getLogger(__name__).warning(
"async-notifier consume failed (TUI)", exc_info=True
)
finally:
# Clear the guard flag regardless of success or exception so
# future notifications can schedule a new consume coroutine.
self._notification_consuming = False
async def _inject_notification_tui(
self,
text: str,
notifs: list,
*,
target_thread_id: str | None = None,
) -> None:
"""Run a synthetic user turn for the batched async-task notification.
Renders one compact tool-result-style line per task (matching the
Rich CLI aesthetic) instead of a single breadcrumb. The LLM still
receives the full ``format_batch_message`` text; only the visual
representation changes.
Args:
text: Full structured LLM message from ``format_batch_message``.
notifs: Survivor notification list for per-task visual rendering.
target_thread_id: Pinned thread id for the synthetic turn —
forwarded to ``_run_turn`` so a mid-consume ``/new`` cannot
misroute the notification into a different thread.
"""
from EvoScientist.cli.async_notifier import format_notification_lines
for line_text, line_style in format_notification_lines(notifs):
self._append_system(line_text, style=line_style)
# Fire-and-forget the turn as an INDEPENDENT task — matches the
# keyboard input path (line ~2113). Queue-triggered turns that
# `await _run_turn` from inside a nested call_later chain don't
# get viewport-follow during streaming (only after completion).
# Mark busy synchronously so the next poll tick doesn't re-enter.
self._busy = True
effective_tid = target_thread_id or self._conversation_tid
async def _run_and_publish() -> None:
response = await self._run_turn(
text,
skip_user_message=True,
resolve_mentions=False,
thread_id_override=target_thread_id,
)
if _ch_mod.publish_to_channel_origin(effective_tid, response or ""):
# Mirror a normal channel turn's closing "Replied to" line
# so the forwarded notification reads as terminated.
_origin = _ch_mod.get_channel_origin(effective_tid)
if _origin is not None:
self._append_system(
f"[{_origin.channel_type}: Replied to "
f"{_origin.sender or _origin.chat_id}]",
style="dim",
)
self._run_task = asyncio.ensure_future(_run_and_publish())
async def _read_async_tasks_tui(self, target_thread_id: str) -> AsyncTasksState:
"""Read async_tasks from agent state for dedup, against a frozen tid.
``target_thread_id`` is captured by ``_consume_notifications_tui`` at
the start of the consume call so a mid-consume thread switch cannot
make us read the wrong thread's state.
"""
agent = self._agent_loader.agent
if agent is None:
return {}
try:
return await read_async_tasks_from_gateway(
self._graph_gateway(),
GraphTarget(
local_graph=agent,
workspace_dir=self._workspace_dir,
),
target_thread_id,
)
except Exception:
return {}
async def _on_channel_cmd_completed(
self,
ctx: CommandContext,
original_agent: Any,
cmd: Command,
) -> None:
await _sync_tui_command_completion(self, ctx, original_agent, cmd)
# ── Widget helpers ─────────────────────────────────────
def _anchor_chat(self, container: VerticalScroll | None = None) -> None:
"""Re-engage the scroll anchor so the viewport pins to the bottom.
Only engages the anchor when the chat content actually overflows
the viewport. Textual's compositor (see ``textual._compositor``)
recomputes ``scroll_y`` for anchored widgets via ``set_reactive``
— which bypasses the validator — so when anchored content is
shorter than the viewport, ``scroll_y`` goes negative and the
welcome banner drops below the visible region (issue #301).
When content fits, we instead release any prior anchor and pin
the viewport to the top.
"""
if container is None:
container = self.query_one("#chat", VerticalScroll)
if container.max_scroll_y > 0:
container.anchor()
else:
self._release_anchor_and_pin_top(container)
def _release_anchor_and_pin_top(self, container: VerticalScroll) -> None:
"""Release any active anchor and force the viewport to the top.
See ``_anchor_chat`` for why this is needed: Textual's compositor
bypasses ``validate_scroll_y`` for anchored widgets, so a leftover
anchor with content shorter than the viewport lets ``scroll_y``
go negative and pushes the welcome banner out of view (issue #301).
"""
container.anchor(False)
container.scroll_home(animate=False, immediate=True)
def _append_system(self, text: str, style: str = "dim") -> None:
"""Mount a SystemMessage widget into #chat."""
container = self.query_one("#chat", VerticalScroll)
container.mount(SystemMessage(text, msg_style=style))
def _mount_renderable(self, renderable: Any) -> None:
"""Mount a Rich renderable (e.g. Table) as a Static widget."""
container = self.query_one("#chat", VerticalScroll)
try:
from .commands import CompactSummaryRenderable
from .widgets.compact_summary_widget import CompactSummaryWidget
except Exception:
CompactSummaryRenderable = None # type: ignore[assignment]
if CompactSummaryRenderable is not None and isinstance(
renderable, CompactSummaryRenderable
):
container.mount(CompactSummaryWidget(renderable.summary_text))
else:
container.mount(Static(renderable))
async def _start_compacting_indicator(self) -> None:
"""Show a transient timer widget while /compact is running."""
await self._stop_compacting_indicator()
container = self.query_one("#chat", VerticalScroll)
widget = CompactingWidget()
self._compacting_widget = widget
await container.mount(widget)
async def _stop_compacting_indicator(self) -> None:
"""Remove the transient /compact progress widget, if present."""
widget = self._compacting_widget
self._compacting_widget = None
if widget is not None:
try:
await widget.cleanup()
except Exception:
try:
await widget.remove()
except Exception:
pass
async def _wait_for_approval(self, approval_widget) -> Any:
"""Wait for user to interact with an ApprovalWidget.
Returns the ``ApprovalWidget.Decided`` message, or ``None`` on
timeout / cancellation.
"""
self._approval_future = asyncio.get_event_loop().create_future()
try:
return await asyncio.wait_for(self._approval_future, timeout=300)
except (TimeoutError, asyncio.CancelledError):
return None
finally:
self._approval_future = None
def on_approval_widget_decided(self, event) -> None: # type: ignore[override]
"""Handle ApprovalWidget.Decided message."""
if self._approval_future and not self._approval_future.done():
self._approval_future.set_result(event)
async def _wait_for_ask_user(self, ask_w) -> dict:
"""Wait for the interactive ask_user widget to resolve via Future.
Returns ``{"answers": [...], "status": "answered"}``
or ``{"status": "cancelled"}``.
"""
loop = asyncio.get_running_loop()
self._ask_user_future = loop.create_future()
ask_w.set_future(self._ask_user_future)
try:
result = await asyncio.wait_for(self._ask_user_future, timeout=300)
except (TimeoutError, asyncio.CancelledError):
ask_w.action_cancel()
return {"status": "cancelled"}
finally:
self._ask_user_future = None
if not isinstance(result, dict):
return {"status": "cancelled"}
result_type = result.get("type", "")
if result_type == "answered":
return {"answers": result.get("answers", []), "status": "answered"}
return {"status": "cancelled"}
async def _wait_for_thread_pick(
self, picker_widget: ThreadPickerWidget
) -> str | None:
"""Wait for user to pick a thread from ThreadPickerWidget.
Returns the selected thread_id, or ``None`` on cancel/timeout.
"""
self._picker_future = asyncio.get_event_loop().create_future()
try:
return await asyncio.wait_for(self._picker_future, timeout=120)
except (TimeoutError, asyncio.CancelledError):
return None
finally:
self._picker_future = None
try:
picker_widget.remove()
except Exception:
pass
self.query_one("#prompt", ChatTextArea).focus()
def on_thread_picker_widget_picked(self, event) -> None: # type: ignore[override]
"""Handle ThreadPickerWidget.Picked message."""
if self._picker_future and not self._picker_future.done():
self._picker_future.set_result(event.thread_id)
def on_thread_picker_widget_cancelled(self, event) -> None: # type: ignore[override]
"""Handle ThreadPickerWidget.Cancelled message."""
if self._picker_future and not self._picker_future.done():
self._picker_future.set_result(None)
async def _wait_for_skill_browse(self, browser_widget) -> list[str] | None:
"""Wait for user to complete skill browsing.
Returns list of install sources, or None on cancel/timeout.
"""
self._browser_future = asyncio.get_event_loop().create_future()
try:
return await asyncio.wait_for(self._browser_future, timeout=300)
except (TimeoutError, asyncio.CancelledError):
return None
finally:
self._browser_future = None
try:
browser_widget.remove()
except Exception:
pass
self.query_one("#prompt", ChatTextArea).focus()
def on_skill_browser_widget_confirmed(self, event) -> None: # type: ignore[override]
"""Handle SkillBrowserWidget.Confirmed message."""
if self._browser_future and not self._browser_future.done():
self._browser_future.set_result(event.install_sources)
def on_skill_browser_widget_cancelled(self, event) -> None: # type: ignore[override]
"""Handle SkillBrowserWidget.Cancelled message."""
if self._browser_future and not self._browser_future.done():
self._browser_future.set_result(None)
# ── MCP browser ───────────────────────────────────────
async def _wait_for_mcp_browse(self, browser_widget) -> list | None:
"""Wait for user to complete MCP server browsing."""
self._mcp_browser_future = asyncio.get_event_loop().create_future()
try:
return await asyncio.wait_for(self._mcp_browser_future, timeout=300)
except (TimeoutError, asyncio.CancelledError):
return None
finally:
self._mcp_browser_future = None
try:
browser_widget.remove()
except Exception:
pass
self.query_one("#prompt", ChatTextArea).focus()
def on_mcpbrowser_widget_confirmed(self, event) -> None: # type: ignore[override]
"""Handle MCPBrowserWidget.Confirmed message."""
if self._mcp_browser_future and not self._mcp_browser_future.done():
self._mcp_browser_future.set_result(event.entries)
def on_mcpbrowser_widget_cancelled(self, event) -> None: # type: ignore[override]
"""Handle MCPBrowserWidget.Cancelled message."""
if self._mcp_browser_future and not self._mcp_browser_future.done():
self._mcp_browser_future.set_result(None)
async def _wait_for_model_pick(self, picker_widget) -> tuple[str, str] | None:
"""Wait for user to pick a model from ModelPickerWidget.
Returns ``(name, provider)`` or ``None`` on cancel/timeout.
"""
self._model_picker_future = asyncio.get_event_loop().create_future()
try:
return await asyncio.wait_for(self._model_picker_future, timeout=120)
except (TimeoutError, asyncio.CancelledError):
return None
finally:
self._model_picker_future = None
try:
picker_widget.remove()
except Exception:
_channel_logger.debug("model picker cleanup failed", exc_info=True)
self.query_one("#prompt", ChatTextArea).focus()
def on_model_picker_widget_picked(self, event) -> None: # type: ignore[override]
"""Handle ModelPickerWidget.Picked message."""
if self._model_picker_future and not self._model_picker_future.done():
self._model_picker_future.set_result((event.name, event.provider))
def on_model_picker_widget_cancelled(self, event) -> None: # type: ignore[override]
"""Handle ModelPickerWidget.Cancelled message."""
if self._model_picker_future and not self._model_picker_future.done():
self._model_picker_future.set_result(None)
# ── Streaming core ─────────────────────────────────────
async def _stream_with_widgets(
self,
user_text: str,
*,
display_text: str | None = None,
on_thinking_cb: Callable[[str], None] | None = None,
on_todo_cb: Callable[[list[dict]], None] | None = None,
on_media_cb: Callable[[str], None] | None = None,
skip_user_message: bool = False,
file_warnings: list[str] | None = None,
channel_hitl_fn: Callable[[list], list[dict] | None] | None = None,
channel_ask_user_fn: Callable[[dict], dict] | None = None,
cancel_scope: str | None = None,
thread_id_override: str | None = None,
) -> str:
"""Stream agent events and mount widgets. Returns response text.
Shared by ``_run_turn`` (interactive) and
``_process_channel_message`` (channel).
Args:
display_text: Text to show in UserMessage widget. When
``None`` (default), falls back to *user_text*. This
allows callers to show the original user input while
sending the resolved (e.g. @file-expanded) text to
the agent.
skip_user_message: If True, don't mount UserMessage (caller
already mounted it — e.g. channel messages with labels).
channel_hitl_fn: Optional channel-based HITL approval function.
When provided (channel messages), this is called instead
of mounting the ApprovalWidget.
channel_ask_user_fn: Optional channel-based ask_user function.
When provided (channel messages), this is called instead
of mounting the AskUserWidget.
"""
from ..stream.display import (
is_stream_cancel_requested,
)
container = self.query_one("#chat", VerticalScroll)
self._chat_following = True
self._new_content_below = False
# 1. Mount user message + loading spinner
if not skip_user_message:
await container.mount(UserMessage(display_text or user_text))
# Mount file warnings after user message so they appear in the
# correct position (between user input and model response).
for w in file_warnings or []:
self._append_system(f"⚠ {w}", style="yellow")
loading = LoadingWidget()
await container.mount(loading)
container.scroll_end(animate=False)
# 2. Event-driven widget rendering
state = StreamState()
loading_removed = False
thinking_w: ThinkingWidget | None = None
summarization_w: SummarizationWidget | None = None
todo_w: TodoWidget | None = None
tool_widgets: dict[str, ToolCallWidget] = {}
subagent_widgets: dict[str, SubAgentWidget] = {}
@dataclass
class _ResponseDisplayState:
assistant: AssistantMessage | None = None
narration: AssistantMessage | None = None
assistant_start: int = 0
narrated_end: int = 0
response_display = _ResponseDisplayState()
# Transient indicator widgets (auto-removed on state transitions)
processing_w: Static | None = None # "Analyzing results..."
# Tool collapsing (matches CLI MAX_VISIBLE_TOOLS)
_MAX_VISIBLE_TOOLS = 4
completed_tool_order: list[str] = [] # tool_ids in completion order
collapse_summary_w: Static | None = None
_thinking_sent = False
_todo_sent = False
_media_sent: set[str] = set()
_MIN_THINKING_LEN = 200
metadata = build_metadata(self._workspace_dir, self._current_model)
response = ""
agent = await self._await_agent_ready()
async def _remove_w(w: Widget | None) -> None:
"""Safely remove a transient indicator widget."""
if w is not None:
try:
await w.remove()
except Exception:
pass
async def _mount_or_update_narration(text: str) -> None:
"""Show the current between-tool text segment inline."""
content = text.strip()
if not content:
return
if response_display.narration is None:
response_display.narration = AssistantMessage(content)
await container.mount(response_display.narration)
else:
response_display.narration._content = content
await response_display.narration.stop_stream()
response_display.narrated_end = len(state.response_text)
async def _convert_assistant_to_narration() -> None:
"""Turn a provisional answer into inline narration before a tool."""
if response_display.assistant is None:
return
content = response_display.assistant._content
if content.strip():
narration = AssistantMessage(content.strip())
try:
await container.mount(
narration, before=response_display.assistant
)
except Exception:
await container.mount(narration)
response_display.narrated_end = max(
response_display.narrated_end,
response_display.assistant_start + len(content),
)
try:
await response_display.assistant.remove()
except Exception:
pass
response_display.assistant = None
response_display.assistant_start = len(state.response_text)
response_display.narration = None
async def _preserve_active_narration() -> None:
"""Finalize inline narration without removing it from the transcript."""
if response_display.narration is not None:
await response_display.narration.stop_stream()
response_display.narration = None
async def _mark_cancelled_response() -> str:
previous_text = state.response_text or ""
current, final_segment, final_text = _stopped_response_after_narration(
previous_text,
response_display.narrated_end,
)
state.response_text = final_text
self._set_status_streaming_text(final_segment)
await _preserve_active_narration()
_expand_completed_tools()
if response_display.assistant is None:
if final_segment:
response_display.assistant_start = len(final_text) - len(
final_segment
)
response_display.assistant = AssistantMessage(final_segment)
await container.mount(response_display.assistant)
else:
if response_display.assistant._content != current:
response_display.assistant._content = final_segment
await response_display.assistant.stop_stream()
else:
suffix = final_segment[len(current) :]
if suffix:
await response_display.assistant.append_content(suffix)
return final_text
def _finalize_active_summarization() -> None:
"""Stop the active summary timer once the stream moves on."""
if summarization_w is not None and summarization_w._is_active:
summarization_w.finalize()
async def _collapse_completed_tools() -> None:
"""Hide older completed tool widgets; show summary line."""
nonlocal collapse_summary_w
completed = [
(tid, tool_widgets[tid])
for tid in completed_tool_order
if tid in tool_widgets
]
n = len(completed)
if n <= _MAX_VISIBLE_TOOLS:
if collapse_summary_w is not None:
collapse_summary_w.display = False
return
to_hide = n - _MAX_VISIBLE_TOOLS
ok_count = 0
fail_count = 0
for i, (_, tw) in enumerate(completed):
if i < to_hide:
tw.display = False
if tw._status == "success":
ok_count += 1
else:
fail_count += 1
else:
tw.display = True
summary = Text()
summary.append(f"\u2713 {ok_count} completed", style="dim green")
if fail_count > 0:
summary.append(f" | {fail_count} failed", style="dim red")
if collapse_summary_w is None:
collapse_summary_w = Static(summary)
# Position before first visible tool widget
first_visible = None
for _, tw in completed[to_hide:]:
if tw.display:
first_visible = tw
break
if first_visible:
await container.mount(collapse_summary_w, before=first_visible)
else:
await container.mount(collapse_summary_w)
else:
collapse_summary_w.update(summary)
collapse_summary_w.display = True
def _expand_completed_tools() -> None:
"""Show every completed tool once the turn reaches a final state."""
if collapse_summary_w is not None:
collapse_summary_w.display = False
for tw in tool_widgets.values():
tw.display = True
def _get_sa_widget(
instance_id: str,
name: str = "",
description: str = "",
) -> SubAgentWidget | None:
if instance_id in subagent_widgets:
w = subagent_widgets[instance_id]
if name and w._sa_name != name:
w.update_name(name, description or w._description)
if description and not w._description:
w.update_name(w._sa_name, description)
return w
return None
_MAX_HITL_ROUNDS = 50
_stream_input: Any = user_text # str or Command for HITL resume
graph_gateway = self._graph_gateway()
for _hitl_round in range(_MAX_HITL_ROUNDS):
if is_stream_cancel_requested(cancel_scope):
response = await _mark_cancelled_response()
break
state.pending_interrupt = None
state.pending_ask_user = None
_hitl_resuming = False
# Reset per-round widgets so resumed streams get fresh ones
if _hitl_round > 0:
thinking_w = None
summarization_w = None
try:
_anchor_engaged = False
async for event in graph_gateway.stream_events(
RunRequest(
message=_stream_input,
thread_id=thread_id_override or self._conversation_tid,
metadata=metadata,
target=GraphTarget(
local_graph=agent,
workspace_dir=self._workspace_dir,
),
)
):
if is_stream_cancel_requested(cancel_scope):
response = await _mark_cancelled_response()
break
if container.max_scroll_y > 0:
at_end = container.is_vertical_scroll_end
if not _anchor_engaged:
_anchor_engaged = True
if at_end:
container.anchor()
else:
self._chat_following = False
self._new_content_below = True
elif self._chat_following and not at_end:
self._chat_following = False
self._new_content_below = True
elif not self._chat_following and at_end:
container.anchor()
self._chat_following = True
self._new_content_below = False
elif container.is_anchored:
# Content no longer overflows (e.g. loading widget
# was just removed). Release the anchor so the
# compositor doesn't pin scroll_y to a negative
# value on the next layout pass (issue #301).
self._release_anchor_and_pin_top(container)
event_type = state.handle_event(event)
new_phase = state.compute_phase()
if new_phase != self._status_phase:
self._status_phase = new_phase
self._render_status()
if event_type == "usage_stats":
self._set_status_usage_baseline(state.last_input_tokens)
if _should_finalize_active_summarization(event_type):
_finalize_active_summarization()
# -- Channel callbacks (thinking, todo, media) --
if (
on_thinking_cb
and not _thinking_sent
and state.thinking_text
and event_type != "thinking"
and len(state.thinking_text) >= _MIN_THINKING_LEN
):
on_thinking_cb(state.thinking_text.rstrip())
_thinking_sent = True
if (
on_todo_cb
and not _todo_sent
and event_type == "tool_call"
and event.get("name") == "write_todos"
and state.todo_items
):
if (
on_thinking_cb
and not _thinking_sent
and state.thinking_text
and len(state.thinking_text) >= _MIN_THINKING_LEN
):
on_thinking_cb(state.thinking_text.rstrip())
_thinking_sent = True
on_todo_cb(state.todo_items)
_todo_sent = True
if (
on_media_cb
and event_type == "tool_result"
and event.get("success")
):
tool_name = event.get("name", "")
if tool_name in ("write_file", "read_file"):
_forward_media_to_channel(
state,
tool_name,
_media_sent,
on_media_cb,
)
# -- Remove loading spinner on first content event --
if not loading_removed and event_type in (
"thinking",
"text",
"tool_call",
"summarization_start",
"summarization",
):
await loading.cleanup()
loading_removed = True
# -- Widget dispatch --
if event_type == "thinking":
if thinking_w is None:
thinking_w = ThinkingWidget(show_thinking=show_thinking)
await container.mount(thinking_w)
thinking_w.append_text(event.get("content", ""))
elif event_type == "summarization_start":
if (
summarization_w is not None
and not summarization_w._is_active
):
summarization_w = None
if summarization_w is None:
summarization_w = SummarizationWidget()
await container.mount(summarization_w)
elif event_type == "summarization":
content = event.get("content", "")
if (
summarization_w is not None
and not summarization_w._is_active
):
summarization_w = None
if summarization_w is None:
summarization_w = SummarizationWidget()
await container.mount(summarization_w)
if content:
summarization_w.append_text(content)
elif event_type == "tool_selection":
tools = event.get("tools", [])
if tools:
from .widgets.tool_selection_widget import (
ToolSelectionWidget,
)
await container.mount(ToolSelectionWidget(tools))
elif event_type == "text":
chunk = event.get("content", "")
if thinking_w is not None and thinking_w._is_active:
thinking_w.finalize()
# Clear processing indicator
await _remove_w(processing_w)
processing_w = None
if not _is_final_response(state):
await _mount_or_update_narration(state.latest_text)
self._set_status_streaming_text(state.latest_text)
else:
# Stream final response incrementally (both
# text-only replies and post-tool responses).
await _preserve_active_narration()
if response_display.assistant is None:
response_display.assistant_start = max(
response_display.narrated_end,
len(state.response_text) - len(chunk),
)
response_display.assistant = AssistantMessage(
state.response_text[
response_display.assistant_start :
]
)
await container.mount(response_display.assistant)
else:
await response_display.assistant.append_content(
chunk
)
self._set_status_streaming_text(
response_display.assistant._content
)
elif event_type == "tool_call":
tool_name = event.get("name", "unknown")
tool_id = event["id"]
tool_args = event.get("args", {})
# Finalize thinking if still active
if thinking_w is not None and thinking_w._is_active:
thinking_w.finalize()
# Clear transient indicators
await _preserve_active_narration()
await _remove_w(processing_w)
processing_w = None
existing_tool = bool(tool_id and tool_id in tool_widgets)
if response_display.assistant is not None and (
tool_name == "task" or not existing_tool
):
await _convert_assistant_to_narration()
# Task tools are handled by SubAgentWidget.
if tool_name != "task":
if existing_tool:
# Re-emitted with updated args — update in place
existing = tool_widgets[tool_id]
existing._tool_name = tool_name
existing._tool_args = tool_args
try:
existing._render_header()
except Exception:
pass
else:
w = ToolCallWidget(tool_name, tool_args, tool_id)
await container.mount(w)
tool_widgets[tool_id] = w
# Update todo widget on write_todos.
# Insert before tool call widget so Task List
# panel appears above the tool call.
if tool_name == "write_todos" and state.todo_items:
if todo_w is None:
todo_w = TodoWidget(state.todo_items)
if tool_id and tool_id in tool_widgets:
await container.mount(
todo_w,
before=tool_widgets[tool_id],
)
else:
await container.mount(todo_w)
else:
todo_w.update_items(state.todo_items)
elif event_type == "tool_result":
result_name = event.get("name", "unknown")
result_content = event.get("content", "")
result_success = event.get("success", True)
matched_tid = event["id"]
tw = tool_widgets.get(matched_tid)
if tw is not None and tw._status == "running":
if result_success:
tw.set_success(result_content)
else:
tw.set_error(result_content)
# Track completion order for collapsing
if (
tw is not None
and matched_tid not in completed_tool_order
):
completed_tool_order.append(matched_tid)
await _collapse_completed_tools()
# Update todo from results
if (
result_name in ("write_todos", "read_todos")
and state.todo_items
):
if todo_w is None:
todo_w = TodoWidget(state.todo_items)
await container.mount(todo_w)
else:
todo_w.update_items(state.todo_items)
# Show "Analyzing results..." if all tools done, no text yet
if (
_is_final_response(state)
and not state.response_text
and processing_w is None
):
processing_w = Static(
Text("\u25cf Analyzing results...", style="cyan"),
)
await container.mount(processing_w)
elif event_type == "subagent_start":
sa_name = event["name"]
sa_desc = event.get("description", "")
instance_id = event["instance_id"]
existing = _get_sa_widget(instance_id, sa_name, sa_desc)
if existing is None:
sa_w = SubAgentWidget(sa_name, sa_desc)
await container.mount(sa_w)
subagent_widgets[instance_id] = sa_w
elif event_type == "subagent_tool_call":
instance_id = event["instance_id"]
sa_w = _get_sa_widget(
instance_id, event.get("subagent", "")
)
if sa_w is None:
continue
await sa_w.add_tool_call(
event.get("name", "unknown"),
event.get("args", {}),
event["id"],
)
elif event_type == "subagent_tool_result":
instance_id = event["instance_id"]
sa_w = _get_sa_widget(
instance_id, event.get("subagent", "")
)
if sa_w is not None:
sa_w.complete_tool(
event.get("name", "unknown"),
event.get("content", ""),
event.get("success", True),
event["id"],
)
elif event_type == "subagent_end":
instance_id = event["instance_id"]
sa_w = _get_sa_widget(instance_id, event.get("name", ""))
if sa_w is not None:
sa_w.finalize()
elif event_type == "ask_user":
questions = event.get("questions", [])
if questions:
# Channel messages: use channel-based text prompt
if channel_ask_user_fn is not None:
self._append_system(
"Waiting for channel user input...",
style="dim italic",
)
_ask_fn = channel_ask_user_fn
result = await asyncio.to_thread(
lambda f=_ask_fn, e=event: f(e),
)
if is_stream_cancel_requested(cancel_scope):
state.pending_ask_user = None
response = await _mark_cancelled_response()
break
else:
# Interactive TUI: display widget, collect via arrow keys
from .widgets.ask_user_widget import AskUserWidget
_prompt = self.query_one("#prompt", ChatTextArea)
_prompt.disabled = True
ask_w = AskUserWidget(questions)
await container.mount(ask_w)
self.call_after_refresh(ask_w.focus_active)
result = await self._wait_for_ask_user(ask_w)
try:
await ask_w.remove()
except Exception:
pass
_prompt.disabled = False
from langgraph.types import (
Command, # type: ignore[import-untyped]
)
_stream_input = Command(resume=result)
_hitl_resuming = True
break # re-enter outer HITL loop
elif event_type == "interrupt":
action_reqs = event.get("action_requests", [])
n = len(action_reqs) or 1
# HITL: check session auto-approve first
if self._hitl_auto_approve:
from langgraph.types import (
Command, # type: ignore[import-untyped]
)
_stream_input = Command(
resume={
"decisions": [
{"type": "approve"} for _ in range(n)
]
}
)
_hitl_resuming = True
break # re-enter outer HITL loop
# Channel messages: use channel-based text approval
if channel_hitl_fn is not None:
self._append_system(
"Waiting for channel user approval...",
style="dim italic",
)
decisions = await asyncio.to_thread(
channel_hitl_fn,
action_reqs,
)
if is_stream_cancel_requested(cancel_scope):
state.pending_interrupt = None
response = await _mark_cancelled_response()
break
if decisions is not None:
from langgraph.types import (
Command, # type: ignore[import-untyped]
)
_stream_input = Command(
resume={"decisions": decisions}
)
_hitl_resuming = True
break # re-enter outer HITL loop
else:
state.pending_interrupt = None
for tw in tool_widgets.values():
if tw._status == "running":
tw.set_rejected()
self._append_system(
"Tool execution rejected by channel user.",
style="yellow",
)
continue
# Interactive TUI: mount approval widget
# Disable main prompt so it can't steal focus
_prompt = self.query_one("#prompt", ChatTextArea)
_prompt.disabled = True
from .widgets.approval_widget import ApprovalWidget
approval_w = ApprovalWidget(action_reqs)
await container.mount(approval_w)
decided_event = await self._wait_for_approval(approval_w)
await approval_w.remove()
_prompt.disabled = False
if decided_event and decided_event.decisions is not None:
if decided_event.auto_approve_session:
self._hitl_auto_approve = True
from langgraph.types import (
Command, # type: ignore[import-untyped]
)
_stream_input = Command(
resume={"decisions": decided_event.decisions}
)
_hitl_resuming = True
break # re-enter outer HITL loop with resume
else:
state.pending_interrupt = None
for tw in tool_widgets.values():
if tw._status == "running":
tw.set_rejected()
self._append_system(
"Tool execution rejected.",
style="yellow",
)
elif event_type == "done":
# Clean up transient indicators
await _preserve_active_narration()
await _remove_w(processing_w)
processing_w = None
_expand_completed_tools()
# Mount final response
final_response_text = _response_after_narration(
state.response_text,
response_display.narrated_end,
)
clean = _strip_trailing_placeholder_ellipsis(
final_response_text
)
if clean:
response_display.assistant_start = len(
state.response_text
) - len(final_response_text)
if response_display.assistant is None:
response_display.assistant = AssistantMessage(clean)
await container.mount(response_display.assistant)
elif response_display.assistant._content != clean:
response_display.assistant._content = clean
await response_display.assistant.stop_stream()
elif response_display.assistant is not None:
try:
await response_display.assistant.remove()
except Exception:
pass
response_display.assistant = None
# Mount token usage stats with elapsed time
if state.total_input_tokens or state.total_output_tokens:
elapsed = None
if self._turn_started_at:
elapsed = format_duration_compact(
self._turn_started_at
)
await container.mount(
UsageWidget(
state.total_input_tokens,
state.total_output_tokens,
elapsed=elapsed,
)
)
elif event_type == "error":
error_msg = event.get("message", "Unknown error")
self._append_system(f"Error: {error_msg}", style="red")
response = (state.response_text or "").strip()
except asyncio.CancelledError:
# Ctrl+C cancellation: preserve streamed text before the outer
# turn handler appends its interruption notice.
await _mark_cancelled_response()
raise
except Exception as exc:
error_msg = str(exc)
if (
"authentication" in error_msg.lower()
or "api_key" in error_msg.lower()
):
self._append_system(
"Error: API key not configured.",
style="red",
)
self._append_system(
"Run EvoSci onboard to set up your API key.",
style="dim",
)
else:
self._append_system(f"Error: {exc}", style="red")
response = f"Error: {exc}"
finally:
# Clean up loading widget if it wasn't removed yet
if not loading_removed:
try:
await loading.cleanup()
except Exception:
pass
# Clean up transient indicators. Inline narration is transcript
# content, so finalize it without removing the widget.
await _preserve_active_narration()
await _remove_w(processing_w)
# Mark any still-running tool widgets as interrupted
# (skip if HITL approved — tools will continue next round)
if not _hitl_resuming:
_expand_completed_tools()
for tw in tool_widgets.values():
if tw._status == "running":
try:
tw.set_interrupted()
except Exception:
pass
# Finalize any still-active sub-agents
for sa_w in subagent_widgets.values():
if sa_w._is_active:
try:
sa_w.finalize()
except Exception:
pass
# Finalize thinking widget
if thinking_w is not None and thinking_w._is_active:
try:
thinking_w.finalize()
except Exception:
pass
# Finalize assistant message stream
if response_display.assistant is not None:
await response_display.assistant.stop_stream()
# Flush remaining thinking callback
if (
on_thinking_cb
and not _thinking_sent
and state.thinking_text
and len(state.thinking_text) >= _MIN_THINKING_LEN
):
on_thinking_cb(state.thinking_text.rstrip())
# Re-anchor so final content is visible, but only
# if the user hasn't scrolled away.
if self._chat_following:
self._anchor_chat(container)
self._new_content_below = False
# HITL / ask_user: if interrupt was handled, loop back to resume stream
if is_stream_cancel_requested(cancel_scope):
response = await _mark_cancelled_response()
break
if state.pending_interrupt is None and state.pending_ask_user is None:
break # normal completion or rejection — exit HITL loop
# Otherwise _stream_input was set to Command(resume=...)
# by the interrupt handler above; loop continues.
return response
async def _run_turn(
self,
user_text: str,
*,
skip_user_message: bool = False,
resolve_mentions: bool = True,
thread_id_override: str | None = None,
) -> str:
"""Handle a user turn: stream agent response with widgets.
Returns the final response text from ``_stream_with_widgets`` so
callers (notably the async-notifier path) can forward it onward —
e.g. push it back to the originating channel. Returns ``""`` if
the turn was cancelled or the agent failed to load.
Args:
user_text: The user's message text.
skip_user_message: If True, suppress the UserMessage widget echo
(caller has already displayed a visual representation of the
input — e.g. async-notifier per-task lines).
resolve_mentions: If False, skip ``@file`` mention expansion.
Used by synthetic notifier turns whose payload is a fixed
JSON template — keeps the TUI path consistent with the
Rich CLI notifier path which never expands mentions.
thread_id_override: Pin the agent stream to this thread instead
of the live ``self._conversation_tid``. Used by the async
notifier path so a mid-consume ``/new`` cannot redirect a
notification meant for thread A into thread B. Falls back
to the live tid when ``None``.
"""
cancelled = False
response = ""
try:
self._busy = True
self._turn_started_at = datetime.now()
self._status_phase = ResearchPhase.THINKING
self._render_status()
# Resolve @file mentions — inject file contents before sending to agent.
# Use self._workspace_dir (current session) not the startup-captured
# workspace_dir closure, which becomes stale after /new or /resume.
if resolve_mentions:
_, message_to_send, file_warnings = await asyncio.to_thread(
resolve_file_mentions, user_text, self._workspace_dir
)
else:
message_to_send = user_text
file_warnings = []
await self._refresh_status_snapshot(message_to_send)
# Block the turn on MCP tools finishing, if still in flight.
# ``_on_agent_load_failure`` is the sole reporter for load
# errors; callers just return so the send is dropped.
try:
await self._await_agent_ready()
except Exception:
return ""
response = await self._stream_with_widgets(
message_to_send,
display_text=user_text,
file_warnings=file_warnings,
skip_user_message=skip_user_message,
thread_id_override=thread_id_override,
)
except asyncio.CancelledError:
cancelled = True
self._append_system("\nInterrupted by user", style="dim italic #ffe082")
finally:
self._busy = False
self._status_phase = ResearchPhase.IDLE
self._run_task = None
await self._refresh_status_snapshot(reset_streaming_text=True)
self._render_status()
self.query_one("#prompt", ChatTextArea).focus()
# Process next queued message (FIFO) — skip if interrupted
if not cancelled and self._queued_messages:
next_msg = self._queued_messages.pop(0)
self._render_queue_indicator()
self._run_task = asyncio.ensure_future(self._run_turn(next_msg))
return response
async def _process_channel_message(self, msg: ChannelMessage) -> None:
"""Process a channel message: stream agent response and reply.
Display order (matches Rich CLI):
> message content
[channel: Received from sender]
(streaming response)
[channel: Replied to sender]
"""
prompt_widget = None
if not _ch_mod._claim_or_complete_channel_request(msg):
return
_ch_mod.remember_channel_origin(self._conversation_tid, msg)
try:
self._busy = True
self._turn_started_at = datetime.now()
self._status_phase = ResearchPhase.THINKING
await self._refresh_status_snapshot(msg.content)
self._render_status()
prompt_widget = self.query_one("#prompt", ChatTextArea)
prompt_widget.disabled = True
# Mount user message first, then "Received" label
container = self.query_one("#chat", VerticalScroll)
await container.mount(UserMessage(msg.content))
self._append_system(
f"[{msg.channel_type}: Received from {msg.sender}]",
style="dim",
)
# Build channel callbacks (fire-and-forget to avoid blocking UI)
def _send_to_channel(coro, label: str) -> None:
loop = _ch_mod._bus_loop
if not loop:
return
future = asyncio.run_coroutine_threadsafe(coro, loop)
future.add_done_callback(
lambda f: (
_channel_logger.debug(
f"{label} send failed: {f.exception()}"
)
if f.exception()
else None
)
)
def _send_thinking(thinking: str) -> None:
ch = msg.channel_ref
if ch and ch.send_thinking:
_send_to_channel(
ch.send_thinking_message(
sender=msg.chat_id,
thinking=thinking,
metadata=msg.metadata,
),
"Thinking",
)
def _send_todo(items: list[dict]) -> None:
from ..channels.consumer import _format_todo_list
if msg.channel_ref:
_send_to_channel(
msg.channel_ref.send_todo_message(
sender=msg.chat_id,
content=_format_todo_list(items),
metadata=msg.metadata,
),
"Todo",
)
def _send_media(file_path: str) -> None:
if msg.channel_ref:
_send_to_channel(
msg.channel_ref.send_media(
recipient=msg.chat_id,
file_path=file_path,
metadata=msg.metadata,
),
"Media",
)
def _channel_hitl_prompt(action_requests: list) -> list[dict] | None:
"""Send HITL approval prompt to channel user and wait for reply.
This runs in a thread (called via asyncio.to_thread) so it can
block without freezing the Textual event loop.
"""
return _ch_mod.channel_hitl_prompt(action_requests, msg)
def _channel_ask_user(ask_user_data: dict) -> dict:
"""Send ask_user questions to channel user and wait for reply.
This runs in a thread (called via asyncio.to_thread) so it can
block without freezing the Textual event loop.
"""
return _ch_mod.channel_ask_user_prompt(ask_user_data, msg)
# Handle slash commands from channel via the shared
# dispatcher (same path Rich CLI and headless serve use).
# Returns True when the command was handled (or errored)
# and we must NOT fall through to agent streaming.
_slash_handled = await dispatch_channel_slash_command(
msg,
agent=None, # resolved via await_agent_ready on demand
thread_id=self._conversation_tid,
workspace_dir=self._workspace_dir,
checkpointer=self._checkpointer,
append_system=self._append_system,
start_new_session_cb=self.start_new_session,
handle_session_resume_cb=self.handle_session_resume,
await_agent_ready=self._await_agent_ready,
on_cmd_completed=self._on_channel_cmd_completed,
channel_runtime=self._channel_runtime,
graph_gateway=self._runtime_gateways.graph_gateway,
)
if _slash_handled:
# A channel-issued /new or /resume rotates the thread in
# the dispatch above; re-bind the now-current thread to
# this channel so async-notifier turns on it still forward.
_ch_mod.remember_channel_origin(self._conversation_tid, msg)
return # outer finally handles _busy / widget cleanup
# Non-slash message — streams through the agent, so wait
# for readiness now.
try:
await self._await_agent_ready()
except Exception as exc:
_set_channel_response(msg.msg_id, f"Error: {exc}")
return
response = ""
try:
response = await self._stream_with_widgets(
msg.content,
on_thinking_cb=_send_thinking
if self._channel_send_thinking
else None,
on_todo_cb=_send_todo,
on_media_cb=_send_media,
skip_user_message=True,
channel_hitl_fn=_channel_hitl_prompt,
channel_ask_user_fn=_channel_ask_user,
cancel_scope=_ch_mod._channel_message_cancel_scope(msg),
)
except Exception as exc:
response = f"Error: {exc}"
self._append_system(f"Error: {exc}", style="red")
_set_channel_response(msg.msg_id, response)
self._append_system(
f"[{msg.channel_type}: Replied to {msg.sender}]",
style="dim",
)
finally:
self._busy = False
self._status_phase = ResearchPhase.IDLE
await self._refresh_status_snapshot(reset_streaming_text=True)
self._render_status()
if prompt_widget is not None:
prompt_widget.disabled = False
prompt_widget.focus()
_ch_mod._complete_channel_request(msg.msg_id)
# ── Clipboard (copy on mouse select) ─────────────────
def on_mouse_up(self, event: MouseUp) -> None:
"""Copy mouse-selected text to clipboard on release."""
copy_selection_to_clipboard(self)
# ── Input handling ─────────────────────────────────────
async def on_chat_text_area_submitted(
self, event: ChatTextArea.Submitted
) -> None:
text = event.value.strip()
prompt = self.query_one("#prompt", ChatTextArea)
prompt.value = ""
self._quit_pending = False
self._history_index = -1
self._history_saved_input = ""
if not text:
return
if self._busy:
# Queue the message to send after current turn finishes
self._queued_messages.append(text)
self._render_queue_indicator()
return
if text.startswith("/"):
self._hide_completions()
# Launch as independent task to free the message pump.
# Commands like /resume mount interactive widgets that need
# the pump to process key events and message bubbling.
_task = asyncio.create_task(self._handle_command(text))
self._background_tasks.add(_task)
_task.add_done_callback(self._background_tasks.discard)
return
self._history_suggester.append_entry(text)
self._run_task = asyncio.ensure_future(self._run_turn(text))
def _build_file_candidates(self, text: str) -> list:
"""Build CompletionCandidate list for @file mentions."""
import re as _re
from ..commands._completion_engine import CompletionCandidate
candidates = complete_file_mention(text, self._workspace_dir)
if not candidates:
return []
m = _re.search(r'@"[^"\n]*$|@[^\s"\']*$', text)
start = m.start() if m else len(text)
return [
CompletionCandidate(
text=path if path.startswith("@") else f"@{path}",
description=type_hint,
replace_start=start,
replace_end=len(text),
)
for path, type_hint in candidates
]
def on_text_area_changed(self, event: ChatTextArea.Changed) -> None:
text = event.text_area.text
comp_widget = self.query_one("#completions", Static)
# Slash-command completions take priority over @file
if text.startswith("/"):
from ..commands._completion_engine import compute_completions
result = compute_completions(text, len(text))
if result.kind == "empty" or not result.candidates:
self._hide_completions()
return
self._comp_items = result.candidates
self._comp_index = -1
c0 = result.candidates[0]
self._comp_base = text[: c0.replace_start]
self._render_completions()
comp_widget.display = True
return
# @file mention completion (only for non-command input)
if "@" in text:
file_items = self._build_file_candidates(text)
if file_items:
self._comp_items = file_items
self._comp_index = -1
self._render_completions()
comp_widget.display = True
return
self._hide_completions()
def _render_queue_indicator(self) -> None:
"""Render the queued messages indicator above the input."""
queued_w = self.query_one("#queued-message", Static)
if not self._queued_messages:
queued_w.display = False
return
parts: list[tuple[str, str]] = []
for msg in self._queued_messages:
preview = msg if len(msg) <= 60 else msg[:57] + "\u2026"
parts.append(("\u276f ", "bold"))
parts.append((preview, ""))
parts.append(("\n", ""))
parts.append(
(" [press up to edit last \u00b7 esc to cancel last]", "dim italic")
)
queued_w.update(Text.assemble(*parts))
queued_w.display = True
def action_cancel_queued(self) -> None:
"""Cancel the last queued message on Esc."""
comp_widget = self.query_one("#completions", Static)
if comp_widget.display:
self._hide_completions()
return
# Cancel ask_user if active (widget handles Escape internally,
# but this is a safety fallback)
if self._ask_user_future and not self._ask_user_future.done():
try:
from .widgets.ask_user_widget import AskUserWidget
ask_w = self.query_one(AskUserWidget)
ask_w.action_cancel()
except Exception:
# Force-resolve the future
self._ask_user_future.set_result({"type": "cancelled"})
return
# Delegate to focused interactive widget
focused = self.focused
if focused is not None:
from .widgets.approval_widget import ApprovalWidget
from .widgets.mcp_browser import MCPBrowserWidget
from .widgets.model_picker import ModelPickerWidget
from .widgets.skill_browser import SkillBrowserWidget
from .widgets.thread_selector import ThreadPickerWidget
if isinstance(focused, ApprovalWidget):
focused.action_select_reject()
return
if isinstance(focused, ThreadPickerWidget):
focused.action_cancel()
return
if isinstance(focused, SkillBrowserWidget):
focused.action_cancel()
return
if isinstance(focused, MCPBrowserWidget):
focused.action_cancel()
return
# ModelPickerWidget: when in "Custom Ollama" input mode, its
# child Input widget owns focus, so ``focused`` isn't the
# picker itself. Walk the parent chain to find it, then let
# the widget's own action_cancel decide whether to close the
# picker (list mode) or just exit input mode.
picker: ModelPickerWidget | None = None
if isinstance(focused, ModelPickerWidget):
picker = focused
else:
node = focused.parent
while node is not None and not isinstance(node, ModelPickerWidget):
node = node.parent
picker = node
if picker is not None:
prev_mode = getattr(picker, "_mode", "list")
picker.action_cancel()
# In list mode action_cancel posted Cancelled; resolve the
# future immediately to avoid a frame of lag. In input
# mode action_cancel flipped back to list — keep picker
# open, do NOT close the future.
if prev_mode == "list":
if (
self._model_picker_future
and not self._model_picker_future.done()
):
self._model_picker_future.set_result(None)
return
if self._queued_messages:
self._queued_messages.pop()
self._render_queue_indicator()
def action_edit_queued(self) -> None:
"""Pop the last queued message back into input for editing."""
# Handle completion list selection (up key)
comp_widget = self.query_one("#completions", Static)
if comp_widget.display and self._comp_items:
n = len(self._comp_items)
if self._comp_index <= 0:
self._comp_index = n - 1
else:
self._comp_index -= 1
self._render_completions()
return
# Skip if an interactive picker widget has focus
focused = self.focused
if focused is not None:
from .widgets.approval_widget import ApprovalWidget
from .widgets.ask_user_widget import AskUserWidget
from .widgets.mcp_browser import MCPBrowserWidget
from .widgets.model_picker import ModelPickerWidget
from .widgets.skill_browser import SkillBrowserWidget
from .widgets.thread_selector import ThreadPickerWidget
if isinstance(focused, ApprovalWidget):
focused.action_move_up()
return
if isinstance(focused, AskUserWidget):
focused.action_move_up()
return
if isinstance(focused, ThreadPickerWidget):
focused.action_move_up()
return
if isinstance(focused, SkillBrowserWidget):
focused.action_move_up()
return
if isinstance(focused, MCPBrowserWidget):
focused.action_move_up()
return
# ModelPickerWidget: Up from the Custom Ollama Input child
# must reach the picker (to exit input mode). See the Esc
# handler above for the parent-walk rationale.
picker_up: ModelPickerWidget | None = None
if isinstance(focused, ModelPickerWidget):
picker_up = focused
else:
node = focused.parent
while node is not None and not isinstance(node, ModelPickerWidget):
node = node.parent
picker_up = node
if picker_up is not None:
picker_up.action_move_up()
return
if self._queued_messages:
last = self._queued_messages.pop()
prompt = self.query_one("#prompt", ChatTextArea)
prompt.value = last
prompt.focus()
self._render_queue_indicator()
return
# History browsing (up key)
entries = self._history_suggester._entries
if not entries:
return
prompt = self.query_one("#prompt", ChatTextArea)
if self._history_index == -1:
# Save current input before entering history
self._history_saved_input = prompt.value
if self._history_index + 1 < len(entries):
self._history_index += 1
prompt.value = entries[self._history_index]
prompt.focus()
def action_down_delegate(self) -> None:
"""Delegate down key to focused interactive widget."""
# Handle completion list selection (down key)
comp_widget = self.query_one("#completions", Static)
if comp_widget.display and self._comp_items:
self._comp_index = (self._comp_index + 1) % len(self._comp_items)
self._render_completions()
return
focused = self.focused
if focused is not None:
from .widgets.approval_widget import ApprovalWidget
from .widgets.ask_user_widget import AskUserWidget
from .widgets.mcp_browser import MCPBrowserWidget
from .widgets.model_picker import ModelPickerWidget
from .widgets.skill_browser import SkillBrowserWidget
from .widgets.thread_selector import ThreadPickerWidget
if isinstance(focused, ApprovalWidget):
focused.action_move_down()
return
if isinstance(focused, AskUserWidget):
focused.action_move_down()
return
if isinstance(focused, ThreadPickerWidget):
focused.action_move_down()
return
if isinstance(focused, SkillBrowserWidget):
focused.action_move_down()
return
if isinstance(focused, MCPBrowserWidget):
focused.action_move_down()
return
# Same parent-walk rationale as action_edit_queued / cancel.
picker_down: ModelPickerWidget | None = None
if isinstance(focused, ModelPickerWidget):
picker_down = focused
else:
node = focused.parent
while node is not None and not isinstance(node, ModelPickerWidget):
node = node.parent
picker_down = node
if picker_down is not None:
picker_down.action_move_down()
return
# History browsing (down key)
if self._history_index >= 0:
prompt = self.query_one("#prompt", ChatTextArea)
self._history_index -= 1
if self._history_index == -1:
# Back to saved input
prompt.value = self._history_saved_input
else:
prompt.value = self._history_suggester._entries[self._history_index]
prompt.focus()
def action_paste_clipboard(self) -> None:
"""Paste text from system clipboard into the input field."""
text = get_clipboard_text()
if not text:
self.notify(
"Clipboard is empty or unavailable",
severity="warning",
timeout=2,
)
return
prompt = self.query_one("#prompt", ChatTextArea)
prompt.insert(text)
prompt.focus()
def action_tab_complete(self) -> None:
"""Handle TAB: apply highlighted completion, or trigger if not visible."""
comp_widget = self.query_one("#completions", Static)
if not (comp_widget.display and self._comp_items):
# Try to trigger completions from current input
prompt = self.query_one("#prompt", ChatTextArea)
prompt.focus()
text = prompt.value
if text.startswith("/"):
from ..commands._completion_engine import compute_completions
result = compute_completions(text, len(text))
if result.kind != "empty" and result.candidates:
self._comp_items = result.candidates
self._comp_index = -1
self._comp_base = text[: result.candidates[0].replace_start]
self._render_completions()
comp_widget.display = True
elif "@" in text:
file_items = self._build_file_candidates(text)
if file_items:
self._comp_items = file_items
self._comp_index = -1
self._render_completions()
comp_widget.display = True
return
if self._comp_index < 0:
self._comp_index = 0
self._render_completions()
self._apply_selected_completion()
selected = self._comp_items[self._comp_index]
is_file_dir = selected.text.startswith("@") and selected.text.rstrip(
'"'
).endswith("/")
if is_file_dir:
return
if selected.text.startswith("@"):
self._hide_completions()
def _handle_completion_enter(self) -> bool:
"""Called by ChatTextArea before submitting on Enter.
If a completion is active and an item is selected, apply it
and suppress the submit. If the list is visible but nothing
is selected (index == -1), select the first item instead of
submitting the raw prefix.
Returns:
True to suppress submit, False to allow it.
"""
comp_widget = self.query_one("#completions", Static)
if not (comp_widget.display and self._comp_items):
return False
if self._comp_index < 0:
self._comp_index = 0
selected = self._comp_items[self._comp_index]
is_file_dir = selected.text.startswith("@") and selected.text.rstrip(
'"'
).endswith("/")
with self.prevent(ChatTextArea.Changed):
self._apply_selected_completion()
if not is_file_dir:
self._hide_completions()
return True
def _apply_selected_completion(self) -> None:
"""Apply the currently selected completion to the input field.
Callers are responsible for suppressing or allowing Changed
events (e.g. ``self.prevent(ChatTextArea.Changed)`` around
the call when the popup should stay hidden).
"""
if self._comp_index < 0 or self._comp_index >= len(self._comp_items):
return
candidate = self._comp_items[self._comp_index]
prompt = self.query_one("#prompt", ChatTextArea)
if candidate.text.startswith("@"):
import re as _re
is_dir = candidate.text.rstrip('"').endswith("/")
suffix = "" if is_dir else " "
current = prompt.value
m = _re.search(r'@"[^"\n]*$|@[^\s"\']*$', current)
if m:
new_val = current[: m.start()] + candidate.text + suffix
else:
new_val = current + candidate.text + suffix
prompt.value = new_val
else:
prompt.value = self._comp_base + candidate.text + " "
def _hide_completions(self) -> None:
self._comp_items = []
self._comp_index = -1
self.query_one("#completions", Static).display = False
def _render_completions(self) -> None:
comp_text = Text()
last_cat = ""
for i, candidate in enumerate(self._comp_items):
cmd, desc = candidate.text, candidate.description
cat = getattr(candidate, "category", "")
if cat and cat != last_cat:
if last_cat:
comp_text.append("\n")
comp_text.append(f" {cat}\n", style="bold #6b7280")
last_cat = cat
if i == self._comp_index:
comp_text.append(" \u25b8 ", style="bold")
comp_text.append(f"{cmd:<28}", style="bold")
comp_text.append(desc, style="bold")
else:
comp_text.append(" ", style="#888888")
comp_text.append(f"{cmd:<28}", style="#888888")
comp_text.append(desc, style="#888888")
if i < len(self._comp_items) - 1:
comp_text.append("\n")
self.query_one("#completions", Static).update(comp_text)
# ── Slash commands ─────────────────────────────────────
async def _handle_command(self, command: str) -> None:
# Echo the command so the user sees what they ran
self._append_system(command.strip(), style="cyan")
# Block new user input while the command runs (important for slow
# commands like /compact that call an LLM internally).
prompt_widget = self.query_one("#prompt", ChatTextArea)
self._busy = True
prompt_widget.disabled = True
self._render_status()
try:
# Only gate on agent readiness for commands that need it —
# recovery commands like ``/mcp add`` must run even when
# ``_await_agent_ready`` would hang on a broken MCP load.
parsed = cmd_manager.resolve(command)
cmd = None
cmd_args: list[str] = []
agent = None
if parsed is not None:
cmd, cmd_args = parsed
if cmd is not None and cmd.needs_agent(cmd_args):
try:
agent = await self._await_agent_ready()
except Exception:
# ``_on_agent_load_failure`` already surfaced the error.
return
ctx = CommandContext(
agent=agent,
thread_id=self._conversation_tid,
ui=self,
workspace_dir=self._workspace_dir,
checkpointer=self._checkpointer,
input_tokens_hint=self._status_last_input_tokens,
channel_runtime=self._channel_runtime,
graph_gateway=self._runtime_gateways.graph_gateway,
)
if await cmd_manager.execute(command, ctx):
if cmd is None:
return
await _sync_tui_command_completion(
self,
ctx,
self._agent_loader.agent,
cmd,
)
return
self._append_system(f"Unknown command: {command}", style="yellow")
self._render_status()
finally:
self._busy = False
if not self._exiting:
prompt_widget.disabled = False
prompt_widget.focus()
async def _render_history(self, thread_id_value: str) -> None:
"""Render conversation history from a saved thread.
Restores human messages and AI responses (with Markdown and
thinking panels). Tool calls and other intermediate steps are
skipped — they are difficult to faithfully reproduce from
checkpoint data.
"""
messages = await self._runtime_gateways.graph_gateway.get_thread_messages(
thread_id_value
)
if not messages:
return
HISTORY_WINDOW = 50
container = self.query_one("#chat", VerticalScroll)
# Only human and ai messages; skip tool/system/other
display = [
m for m in messages if getattr(m, "type", None) in ("human", "ai")
]
if len(display) > HISTORY_WINDOW:
skipped = len(display) - HISTORY_WINDOW
display = display[-HISTORY_WINDOW:]
await container.mount(
SystemMessage(
f"── ... {skipped} earlier messages ──", msg_style="dim"
)
)
else:
await container.mount(
SystemMessage("── Conversation history ──", msg_style="dim")
)
for message in display:
msg_type = getattr(message, "type", None)
content = getattr(message, "content", "") or ""
if msg_type == "human":
if isinstance(content, list):
parts = [
block.get("text", "")
for block in content
if isinstance(block, dict) and block.get("type") == "text"
]
content = " ".join(parts) if parts else ""
content = content.strip()
if content:
await container.mount(UserMessage(content))
elif msg_type == "ai":
# Extract thinking and text blocks from content list
thinking_text = ""
text_content = ""
if isinstance(content, list):
for block in content:
if not isinstance(block, dict):
continue
if block.get("type") == "thinking":
thinking_text += block.get("thinking", "")
elif block.get("type") == "text":
text_content += block.get("text", "")
else:
text_content = content or ""
text_content = text_content.strip()
# Render thinking as collapsed panel (click to expand)
if thinking_text.strip() and show_thinking:
w = ThinkingWidget(show_thinking=True)
await container.mount(w)
w.append_text(thinking_text)
w.finalize()
# Render AI response with full Markdown
if text_content:
await container.mount(AssistantMessage(text_content))
await container.mount(
SystemMessage("── End of history ──", msg_style="dim")
)
# Anchor so the viewport pins to the bottom as Markdown-heavy
# AssistantMessages finish their async layout reflows.
self._anchor_chat(container)
# ── Quit handling ──────────────────────────────────────
def _arm_quit_pending(self, shortcut: str) -> None:
"""Set the pending-quit flag and show a matching hint."""
self._quit_pending = True
quit_timeout = 3 # seconds
self.notify(f"Press {shortcut} again to quit", timeout=quit_timeout)
self.set_timer(
quit_timeout,
lambda: setattr(self, "_quit_pending", False),
)
def force_quit(self) -> None:
"""Exit immediately without double-press confirmation (used by /exit command)."""
self._do_exit()
def _do_exit(self) -> None:
"""Clean up channels, unregister callbacks, and exit."""
self._exiting = True
self._channel_start_stop.set()
event_sink.set_fallback_display(None)
if self._channel_timer is not None:
self._channel_timer.stop()
self._channel_timer = None
self._channel_start_results.clear()
if _channels_is_running():
try:
_channels_stop(runtime=self._channel_runtime)
except Exception:
pass
self.exit()
def action_request_quit(self) -> None:
if self._busy:
self._quit_pending = False
# Clear all queued messages on interrupt
if self._queued_messages:
self._queued_messages.clear()
self._render_queue_indicator()
if self._run_task is not None and not self._run_task.done():
self._run_task.cancel()
else:
# Edge case: busy but no task — force reset
self._busy = False
self.query_one("#prompt", ChatTextArea).focus()
self._render_status()
self._append_system(
"\nInterrupted by user", style="dim italic #ffe082"
)
return
# Double Ctrl+C to quit
if self._quit_pending:
self._do_exit()
else:
self._arm_quit_pending("Ctrl+C")
# ── Banner & status ────────────────────────────────────
async def _refresh_status_snapshot(
self,
pending_user_text: str | None = None,
*,
reset_streaming_text: bool = True,
) -> None:
"""Recompute persistent status metrics for the active thread."""
pending = (pending_user_text or "").strip()
if pending:
if self._status_last_input_tokens is not None:
self._status_base_snapshot = apply_user_text_to_snapshot(
make_usage_status_snapshot(
self._status_last_input_tokens,
model_name=self._current_model,
),
pending,
)
else:
self._status_base_snapshot = await build_session_status_snapshot(
self._conversation_tid,
model_name=self._current_model,
pending_user_text=pending,
graph_gateway=self._runtime_gateways.graph_gateway,
)
elif self._status_last_input_tokens is not None:
self._status_base_snapshot = make_usage_status_snapshot(
self._status_last_input_tokens,
model_name=self._current_model,
)
else:
self._status_base_snapshot = await build_session_status_snapshot(
self._conversation_tid,
model_name=self._current_model,
graph_gateway=self._runtime_gateways.graph_gateway,
)
if reset_streaming_text:
self._status_streaming_text = ""
self._rebuild_status_snapshot()
def _set_status_usage_baseline(self, input_tokens: int) -> None:
"""Promote the latest real prompt usage into the status-bar base."""
if input_tokens <= 0:
return
self._status_last_input_tokens = input_tokens
self._status_base_snapshot = make_usage_status_snapshot(
input_tokens,
model_name=self._current_model,
)
self._rebuild_status_snapshot()
def update_status_after_compact(self, tokens_after: int) -> None:
"""Update the status bar immediately after a successful /compact.
Called by CompactCommand so the bar reflects the reduced context
without waiting for the next LLM call.
"""
if tokens_after <= 0:
return
self._status_last_input_tokens = tokens_after
self._status_base_snapshot = make_usage_status_snapshot(
tokens_after,
model_name=self._current_model,
)
self._rebuild_status_snapshot()
def update_status_after_model_change(
self, new_model: str, new_provider: str | None = None
) -> None:
"""Update the status bar and welcome banner after /model switches the LLM."""
self._current_model = new_model
if new_provider is not None:
self._current_provider = new_provider
self._status_base_snapshot = make_empty_status_snapshot(new_model)
self._rebuild_status_snapshot()
self._render_welcome()
def _set_status_streaming_text(self, text: str | None) -> None:
"""Update in-flight assistant text shown in the context bar."""
new_text = text or ""
if new_text == self._status_streaming_text:
return
self._status_streaming_text = new_text
self._rebuild_status_snapshot()
def _rebuild_status_snapshot(self) -> None:
"""Compose the displayed snapshot from base state + live overlay."""
self._status_snapshot = apply_assistant_text_to_snapshot(
self._status_base_snapshot,
self._status_streaming_text,
)
self._render_status()
def _render_welcome(self) -> None:
channels_info: list[tuple[str, bool, str]] | None = None
try:
current = get_channel_startup_results()
if current:
self._channel_start_results = current
if self._channel_start_results:
channels_info = self._channel_start_results
else:
from ..config import load_config
cfg = load_config()
if cfg and cfg.channel_enabled:
types = [
t.strip()
for t in cfg.channel_enabled.split(",")
if t.strip()
]
if types:
channels_info = [(ct, False, "configured") for ct in types]
except Exception:
pass
welcome = self.query_one("#welcome", Static)
welcome.update(
_build_welcome_banner(
thread_id=self._conversation_tid,
workspace_dir=self._workspace_dir,
mode=mode,
model=self._current_model,
provider=self._current_provider,
ui_backend="tui",
channels=channels_info,
)
)
async def _render_history_then_pending_notice(self, thread_id: str) -> None:
await self._render_history(thread_id)
self._append_pending_skill_proposals_notice()
def _append_pending_skill_proposals_notice(self) -> None:
from .commands import _pending_skill_proposals_message
message = _pending_skill_proposals_message(self._workspace_dir)
if message:
self._append_system(message, style="yellow")
def _render_status(self) -> None:
status = self.query_one("#status", Static)
width = (
getattr(status.size, "width", 0)
or getattr(status.content_region, "width", 0)
or getattr(self.screen.size, "width", 0)
or 80
)
# MCP load progress lives in the dedicated MCPLoaderWidget
# above the input bar — no need to duplicate it here.
if self._busy:
hint_label, hint_style = self._phase_hint_label()
else:
hint_label = "/help for commands"
hint_style = f"on {STATUS_BAR_BG} {STATUS_HINT_IDLE}"
hint = Text.assemble(
(hint_label, hint_style),
)
if (
self._busy
and self._status_phase != ResearchPhase.THINKING
and self._new_content_below
):
hint.append(" │ ", style=f"on {STATUS_BAR_BG} {STATUS_DIM}")
hint.append(
"↓ New content below",
style=f"on {STATUS_BAR_BG} {STATUS_GOOD} bold",
)
hint.append(" │ ", style=f"on {STATUS_BAR_BG} {STATUS_DIM}")
remaining_width = max(1, width - len(hint.plain))
metrics = build_status_text(
self._status_snapshot,
self._status_started_at,
remaining_width,
)
line = Text(no_wrap=True, overflow="crop")
line.append_text(hint)
line.append_text(metrics)
status.update(line)
def _phase_hint_label(self) -> tuple[str, str]:
"""Return (label, style) for the current research phase."""
phase = self._status_phase
busy_style = f"on {STATUS_BAR_BG} {STATUS_HINT_BUSY} bold"
elapsed = ""
if self._turn_started_at:
elapsed = f" ({format_duration_compact(self._turn_started_at)})"
match phase:
case ResearchPhase.THINKING:
return f"Thinking...{elapsed}", busy_style
case ResearchPhase.RESEARCHING:
return f"Researching...{elapsed}", busy_style
case ResearchPhase.WRITING:
return (
f"Writing report...{elapsed}",
f"on {STATUS_BAR_BG} {STATUS_HINT_WRITING} bold",
)
case _:
# Fallback for busy state with no specific phase (e.g. slash commands)
return f"Working...{elapsed}", busy_style
# ── Media forwarding helper (module-level) ──────────────
_MEDIA_EXTENSIONS = {
".png",
".jpg",
".jpeg",
".gif",
".bmp",
".webp",
".svg",
".pdf",
".mp3",
".wav",
".mp4",
}
def _forward_media_to_channel(
state: StreamState,
tool_name: str,
media_sent: set[str],
send_fn: Any,
) -> None:
"""Check tool calls for media files and forward to channel."""
import os
from ..paths import resolve_virtual_path
arg_key = "path" if tool_name == "write_file" else "file_path"
for tc in reversed(state.tool_calls):
if tc.get("name") == tool_name:
p = tc.get("args", {}).get(arg_key, "")
if not p:
p = tc.get("args", {}).get("path", "")
if p and p not in media_sent:
ext = os.path.splitext(p)[1].lower()
if ext in _MEDIA_EXTENSIONS:
real_path = str(resolve_virtual_path(p))
if not os.path.isfile(real_path) and os.path.isfile(p):
real_path = p
if os.path.isfile(real_path):
media_sent.add(p)
send_fn(real_path)
break
# ── Entry point ─────────────────────────────────────────
async def _amain() -> None:
async with get_checkpointer() as checkpointer:
effective_workspace = workspace_dir
effective_thread_id: str | None = None
resumed = False
resume_warning = ""
if thread_id:
resolution = await graph_gateway.resolve_thread(thread_id)
if resolution.thread_id:
meta = await graph_gateway.get_thread_metadata(resolution.thread_id)
ws = (meta or {}).get("workspace_dir", "")
mismatch_aborted = False
if ws:
effective_workspace = ws
# Sync langgraph dev subprocess to the resumed
# workspace BEFORE the Textual app takes over the
# terminal. Mirrors interactive.py's Rich-CLI fix.
# Without this, --resume against a thread from a
# different workspace would leave background workers
# and deployed sub-agents operating on the launch
# directory's files.
from ..stream.console import console as _resume_console
try:
from ..langgraph_dev.manager import WorkspaceMismatchError
from .commands import (
_sync_background_agent_server_workspace,
)
await _sync_background_agent_server_workspace(
config,
workspace_dir=ws,
)
except WorkspaceMismatchError as _ws_mismatch_exc:
# Surface the user-actionable message via the
# Rich console (TUI hasn't taken over the terminal
# yet) and abort the resume so the TUI doesn't
# start up pointing at the conflicting workspace
# with background work routed at a server pinned to
# a different workspace.
_resume_console.print(f"[red]{_ws_mismatch_exc}[/red]")
mismatch_aborted = True
except Exception as _ws_sync_exc:
# Non-fatal at startup — async sub-agents fall back
# to sync via the manager's own availability flag,
# and memory workers skip while the server is down.
# Surface the exception so unexpected failures
# (import errors, regressions in
# ensure_langgraph_dev, etc.) don't hide silently.
logging.getLogger(__name__).warning(
"TUI startup workspace sync to langgraph dev "
"failed: %s. Async sub-agents will fall back "
"to in-process sync delegation and EvoMemory "
"workers will skip for this session.",
_ws_sync_exc,
)
if mismatch_aborted:
# Revert the workspace mutation and fall through to the
# ``effective_thread_id is None`` branch below, which
# generates a fresh thread in the original launch
# workspace. User keeps the TUI session; the requested
# ``--thread-id`` resume is what we refuse.
effective_workspace = workspace_dir
resume_warning = (
f"Resume of thread '{thread_id}' aborted due to "
"workspace conflict. Starting new session."
)
else:
effective_thread_id = resolution.thread_id
resumed = True
elif resolution.matches:
resume_warning = (
f"Thread prefix '{thread_id}' is ambiguous "
f"({', '.join(resolution.matches)}). Starting new session."
)
else:
resume_warning = (
f"Thread '{thread_id}' not found. Starting new session."
)
if not effective_thread_id:
effective_thread_id = await graph_gateway.create_thread(
GraphTarget(workspace_dir=effective_workspace)
)
# The TUI opens instantly and starts MCP loading in the
# background; ``on_mount`` in the app kicks off the real
# ``load_agent`` call and awaits it before the first turn.
app = EvoTextualInteractiveApp(
thread_id_value=effective_thread_id,
workspace=effective_workspace,
checkpointer=checkpointer,
runtime_gateways=runtime_gateways,
channel_send_thinking_value=channel_send_thinking,
resumed=resumed,
resume_warning=resume_warning,
)
try:
await app.run_async()
finally:
from .resume_hint import print_resume_hint
# Best-effort resume hint — guarded so failures here (e.g.
# DB teardown race during abnormal shutdown) cannot shadow
# the original run_async traceback.
exit_tid = getattr(app, "_conversation_tid", None)
hint_tid: str | None = None
if exit_tid:
try:
if await graph_gateway.thread_exists(exit_tid):
hint_tid = exit_tid
except Exception:
_channel_logger.debug(
"resume-hint thread_exists lookup failed",
exc_info=True,
)
try:
print_resume_hint(hint_tid)
except Exception:
_channel_logger.debug("print_resume_hint failed", exc_info=True)
import nest_asyncio # type: ignore[import-untyped]
nest_asyncio.apply()
try:
loop = asyncio.get_event_loop()
except RuntimeError:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(_amain())
Reference in New Issue View Git Blame Copy Permalink