Files
EvoScientist-Multi/EvoScientist/cli/tui_interactive.py
T

1827 lines
74 KiB
Python

"""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 shlex
from typing import Any, Callable
from rich.console import Group
from rich.table import Table
from rich.text import Text
import EvoScientist.cli.channel as _ch_mod
from .channel import (
ChannelMessage,
_channels_is_running,
_channels_running_list,
_channels_stop,
_auto_start_channel,
_message_queue,
_set_channel_response,
)
from ..sessions import (
_format_relative_time,
delete_thread,
find_similar_threads,
generate_thread_id,
get_checkpointer,
get_thread_messages,
get_thread_metadata,
list_threads,
thread_exists,
)
from ..stream.events import stream_agent_events
from ..stream.state import StreamState, _INTERNAL_TOOLS
from ._constants import LOGO_LINES, LOGO_GRADIENT, WELCOME_SLOGANS, build_metadata
_channel_logger = logging.getLogger(__name__)
_TUI_SLASH_COMMANDS = [
("/current", "Show current session info"),
("/threads", "List recent sessions"),
("/resume", "Resume a previous session"),
("/delete", "Delete a saved session"),
("/new", "Start a new session"),
("/clear", "Clear chat history"),
("/skills", "List installed skills"),
("/install-skill", "Add a skill from path or GitHub"),
("/uninstall-skill", "Remove an installed skill"),
("/mcp", "Manage MCP servers"),
("/channel", "Configure messaging channels"),
("/help", "Show available commands"),
("/exit", "Quit EvoScientist"),
]
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)
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):
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")
info.append("\n Type ", style="#ffe082")
info.append("/", style="#ffe082 bold")
info.append(" for commands", style="#ffe082")
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_visible = 0
n_done = 0
for i, tc in enumerate(state.tool_calls):
if tc.get("name") in _INTERNAL_TOOLS:
continue
n_visible += 1
if i < len(state.tool_results):
n_done += 1
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
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],
) -> None:
"""Run full-screen Textual interactive chat loop."""
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.widgets import Input, Static
from .clipboard import copy_selection_to_clipboard
from .widgets import (
LoadingWidget,
ThinkingWidget,
AssistantMessage,
ToolCallWidget,
SubAgentWidget,
TodoWidget,
UserMessage,
SystemMessage,
)
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."""
CSS = """
Screen {
layout: vertical;
background: #06080d;
color: #d1d5db;
}
#chat {
height: 1fr;
padding: 1 2;
background: #06080d;
}
#welcome {
height: auto;
margin-bottom: 1;
}
#input-shell {
height: auto;
padding: 0 2 1 2;
background: #06080d;
}
#input-row {
height: 3;
border: solid #0284c7;
background: #11151b;
padding: 0 1;
}
#input-cursor {
width: 2;
content-align: center middle;
color: #0284c7;
text-style: bold;
}
#prompt {
width: 1fr;
border: none;
background: transparent;
color: #e5e7eb;
}
#prompt:focus {
border: none;
}
#completions {
display: none;
height: auto;
max-height: 15;
background: #11151b;
padding: 0 1;
border-bottom: solid #0284c7;
}
#status {
height: 1;
background: #171a20;
color: #f59e0b;
padding: 0 1;
}
"""
BINDINGS = [
Binding("ctrl+c", "request_quit", "Quit", show=False),
]
def __init__(
self,
*,
agent: Any,
thread_id_value: str,
workspace: str | None,
checkpointer: Any,
channel_send_thinking_value: bool = True,
resumed: bool = False,
resume_warning: str = "",
) -> None:
super().__init__()
self._agent = agent
self._thread_id = thread_id_value
self._workspace_dir = workspace
self._checkpointer = checkpointer
self._channel_send_thinking = channel_send_thinking_value
self._resumed = resumed
self._resume_warning = resume_warning
self._channel_timer: Any = None
self._started_channel_types: list[str] = []
self._busy = False
self._run_task: Any = None # asyncio.Task for current _run_turn
self._comp_items: list[tuple[str, str]] = []
self._comp_index: int = -1
# ── 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="completions")
with Horizontal(id="input-row"):
yield Static(">", id="input-cursor")
yield Input(
placeholder="Type message (/ for commands)",
id="prompt",
)
yield Static("", id="status")
def on_mount(self) -> None:
self._render_welcome()
self._render_status()
self.query_one("#prompt", Input).focus()
# Show resume status
if self._resume_warning:
self._append_system(self._resume_warning, style="yellow")
elif self._resumed:
self._append_system(
f"Resumed session: {self._thread_id}", style="green",
)
self.call_later(
lambda: asyncio.ensure_future(self._render_history(self._thread_id))
)
# Auto-start channels
self._start_channels()
# ── Channel integration ────────────────────────────────
def _start_channels(self) -> None:
"""Auto-start channels if enabled in config."""
try:
from ..config import load_config
cfg = load_config()
if cfg and cfg.channel_enabled and not _channels_is_running():
_auto_start_channel(
self._agent,
self._thread_id,
cfg,
send_thinking=self._channel_send_thinking,
)
types = [
t.strip()
for t in cfg.channel_enabled.split(",")
if t.strip()
]
self._started_channel_types = types
self._render_welcome()
except Exception as e:
_channel_logger.debug(f"Channel auto-start failed: {e}")
self._channel_timer = self.set_interval(0.1, self._poll_channel_queue)
def _poll_channel_queue(self) -> None:
"""Poll the channel message queue (called every 100ms)."""
try:
msg = _message_queue.get_nowait()
except queue.Empty:
return
if self._busy:
_message_queue.put(msg)
return
self.call_later(lambda m=msg: asyncio.ensure_future(self._process_channel_message(m)))
# ── Widget helpers ─────────────────────────────────────
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))
container.scroll_end(animate=False)
def _mount_renderable(self, renderable: Any) -> None:
"""Mount a Rich renderable (e.g. Table) as a Static widget."""
container = self.query_one("#chat", VerticalScroll)
container.mount(Static(renderable))
container.scroll_end(animate=False)
# ── Streaming core ─────────────────────────────────────
async def _stream_with_widgets(
self,
user_text: str,
*,
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,
) -> str:
"""Stream agent events and mount widgets. Returns response text.
Shared by ``_run_turn`` (interactive) and
``_process_channel_message`` (channel).
Args:
skip_user_message: If True, don't mount UserMessage (caller
already mounted it — e.g. channel messages with labels).
"""
container = self.query_one("#chat", VerticalScroll)
# 1. Mount user message + loading spinner
if not skip_user_message:
await container.mount(UserMessage(user_text))
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
assistant_w: AssistantMessage | None = None
todo_w: TodoWidget | None = None
tool_widgets: dict[str, ToolCallWidget] = {}
subagent_widgets: dict[str, SubAgentWidget] = {}
# Transient indicator widgets (auto-removed on state transitions)
narration_w: Static | None = None # dim italic intermediate text
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
has_used_tools = False
_thinking_sent = False
_todo_sent = False
_media_sent: set[str] = set()
_MIN_THINKING_LEN = 200
metadata = build_metadata(self._workspace_dir, model)
response = ""
async def _remove_w(w: Static | None) -> None:
"""Safely remove a transient indicator widget."""
if w is not None:
try:
await w.remove()
except Exception:
pass
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 _find_or_rename_sa_widget(
resolved_name: str, description: str = "",
) -> SubAgentWidget | None:
"""Look up a sub-agent widget, renaming 'sub-agent' entry if needed."""
if resolved_name in subagent_widgets:
w = subagent_widgets[resolved_name]
if description and not w._description:
w.update_name(w._sa_name, description)
return w
# Rename "sub-agent" → real name (mirrors state._get_or_create_subagent)
if resolved_name != "sub-agent" and "sub-agent" in subagent_widgets:
w = subagent_widgets.pop("sub-agent")
w.update_name(resolved_name, description)
subagent_widgets[resolved_name] = w
return w
return None
try:
async for event in stream_agent_events(
self._agent,
user_text,
self._thread_id,
metadata=metadata,
):
event_type = state.handle_event(event)
# -- 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",
):
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 == "text":
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 has_used_tools and not _is_final_response(state):
# Tools still running — show intermediate narration
await _remove_w(narration_w)
narration_w = None
last_line = state.latest_text.strip().split("\n")[-1].strip()
if last_line:
if len(last_line) > 60:
last_line = last_line[:57] + "\u2026"
narration_w = Static(
Text(f" {last_line}", style="dim italic"),
)
await container.mount(narration_w)
else:
# Stream final response incrementally (both
# text-only replies and post-tool responses).
await _remove_w(narration_w)
narration_w = None
if assistant_w is None:
assistant_w = AssistantMessage(state.response_text)
await container.mount(assistant_w)
else:
await assistant_w.append_content(
event.get("content", ""),
)
elif event_type == "tool_call":
tool_name = event.get("name", "unknown")
tool_id = event.get("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 _remove_w(narration_w)
narration_w = None
await _remove_w(processing_w)
processing_w = None
# Remove early AssistantMessage (text arrived before tools)
if assistant_w is not None:
try:
await assistant_w.remove()
except Exception:
pass
assistant_w = None
# Skip internal tools and task (handled by SubAgentWidget)
if tool_name not in _INTERNAL_TOOLS and tool_name != "task":
has_used_tools = True
if tool_id and tool_id in tool_widgets:
# 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)
if tool_id:
tool_widgets[tool_id] = w
# Update todo widget on write_todos
if tool_name == "write_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)
elif event_type == "tool_result":
result_name = event.get("name", "unknown")
result_content = event.get("content", "")
result_success = event.get("success", True)
# Match via state's deduplicated tool_calls (uses tool_id)
matched = False
matched_tid = ""
result_idx = len(state.tool_results) - 1
if 0 <= result_idx < len(state.tool_calls):
tc = state.tool_calls[result_idx]
tid = tc.get("id", "")
if tid and tid in tool_widgets:
tw = tool_widgets[tid]
if tw._status == "running":
if result_success:
tw.set_success(result_content)
else:
tw.set_error(result_content)
matched = True
matched_tid = tid
# Fallback: match first running widget with same name
if not matched:
for fid, tw in tool_widgets.items():
if tw.tool_name == result_name and tw._status == "running":
if result_success:
tw.set_success(result_content)
else:
tw.set_error(result_content)
matched = True
matched_tid = fid
break
# Track completion order for collapsing
if matched_tid 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.get("name", "sub-agent")
sa_desc = event.get("description", "")
existing = _find_or_rename_sa_widget(sa_name, sa_desc)
if existing is None:
sa_w = SubAgentWidget(sa_name, sa_desc)
await container.mount(sa_w)
subagent_widgets[sa_name] = sa_w
elif event_type == "subagent_tool_call":
sa_name = event.get("subagent", "sub-agent")
sa_name = state._resolve_subagent_name(sa_name)
sa_w = _find_or_rename_sa_widget(sa_name)
if sa_w is None:
sa_w = SubAgentWidget(sa_name)
await container.mount(sa_w)
subagent_widgets[sa_name] = sa_w
await sa_w.add_tool_call(
event.get("name", "unknown"),
event.get("args", {}),
event.get("id", ""),
)
elif event_type == "subagent_tool_result":
sa_name = event.get("subagent", "sub-agent")
sa_name = state._resolve_subagent_name(sa_name)
sa_w = _find_or_rename_sa_widget(sa_name)
if sa_w is not None:
sa_w.complete_tool(
event.get("name", "unknown"),
event.get("content", ""),
event.get("success", True),
event.get("id", ""),
)
elif event_type == "subagent_end":
sa_name = event.get("name", "sub-agent")
sa_name = state._resolve_subagent_name(sa_name)
sa_w = _find_or_rename_sa_widget(sa_name)
if sa_w is not None:
sa_w.finalize()
elif event_type == "done":
# Clean up transient indicators
await _remove_w(narration_w)
narration_w = None
await _remove_w(processing_w)
processing_w = None
# Mount final response
if assistant_w is None and state.response_text:
# Strip trailing standalone "..."
clean = state.response_text.strip()
while clean.endswith("\n...") or clean.rstrip() == "...":
clean = clean.rstrip().removesuffix("...").rstrip()
assistant_w = AssistantMessage(clean or state.response_text)
await container.mount(assistant_w)
# Markdown rendering is async and needs multiple
# layout cycles to compute final height. Schedule
# extra deferred scrolls so the response is visible.
self.set_timer(
0.15,
lambda: container.scroll_end(animate=False),
)
self.set_timer(
0.4,
lambda: container.scroll_end(animate=False),
)
elif event_type == "error":
error_msg = event.get("message", "Unknown error")
self._append_system(f"Error: {error_msg}", style="red")
# Scroll after Textual processes the layout update
self.call_after_refresh(
container.scroll_end, animate=False,
)
response = (state.response_text or "").strip()
except asyncio.CancelledError:
# Ctrl+C cancellation
pass
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
for w in (narration_w, processing_w):
await _remove_w(w)
# Mark any still-running tool widgets as interrupted
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 assistant_w is not None:
await assistant_w.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())
# Final scroll to ensure last content is visible
self.call_after_refresh(
container.scroll_end, animate=False,
)
return response
async def _run_turn(self, user_text: str) -> None:
"""Handle a user turn: stream agent response with widgets."""
self._busy = True
self._render_status()
prompt = self.query_one("#prompt", Input)
prompt.disabled = True
try:
await self._stream_with_widgets(user_text)
finally:
self._busy = False
self._run_task = None
self._render_status()
prompt.disabled = False
prompt.focus()
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]
"""
self._busy = True
self._render_status()
prompt_widget = self.query_one("#prompt", Input)
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",
)
container.scroll_end(animate=False)
# 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",
timeout=30,
)
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,
)
except Exception as exc:
response = f"Error: {exc}"
self._append_system(f"Error: {exc}", style="red")
finally:
self._busy = False
self._render_status()
prompt_widget.disabled = False
prompt_widget.focus()
_set_channel_response(msg.msg_id, response)
self._append_system(
f"[{msg.channel_type}: Replied to {msg.sender}]",
style="dim",
)
# ── 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_input_submitted(self, event: Input.Submitted) -> None:
text = event.value.strip()
prompt = self.query_one("#prompt", Input)
prompt.value = ""
if not text:
return
if self._busy:
self._append_system(
"A response is still streaming. Please wait.",
style="yellow",
)
return
if text.startswith("/"):
self._hide_completions()
await self._handle_command(text)
return
self._run_task = asyncio.ensure_future(self._run_turn(text))
def on_input_changed(self, event: Input.Changed) -> None:
text = event.value
comp_widget = self.query_one("#completions", Static)
if text.startswith("/"):
prefix = text.lower()
matches = [
(cmd, desc)
for cmd, desc in _TUI_SLASH_COMMANDS
if cmd.startswith(prefix)
]
if len(matches) == 1 and matches[0][0] == prefix:
self._hide_completions()
return
if matches:
self._comp_items = matches
self._comp_index = -1
self._render_completions()
comp_widget.display = True
return
self._hide_completions()
def on_key(self, event: Any) -> None:
comp_widget = self.query_one("#completions", Static)
if not (comp_widget.display and self._comp_items):
return
if event.key in ("tab", "down"):
event.prevent_default()
event.stop()
self._comp_index = (self._comp_index + 1) % len(self._comp_items)
self._apply_selected_completion()
elif event.key == "up":
event.prevent_default()
event.stop()
self._comp_index = (self._comp_index - 1) % len(self._comp_items)
self._apply_selected_completion()
elif event.key == "enter" and self._comp_index >= 0:
event.prevent_default()
event.stop()
self._hide_completions()
def _apply_selected_completion(self) -> None:
selected_cmd = self._comp_items[self._comp_index][0]
prompt = self.query_one("#prompt", Input)
prompt.value = selected_cmd + " "
prompt.cursor_position = len(prompt.value)
self._render_completions()
def _hide_completions(self) -> None:
self._comp_items = []
self._comp_index = -1
comp_widget = self.query_one("#completions", Static)
comp_widget.display = False
def _render_completions(self) -> None:
comp_text = Text()
for i, (cmd, desc) in enumerate(self._comp_items):
if i == self._comp_index:
comp_text.append("\u25b8 ", style="bold")
comp_text.append(f"{cmd:<22}", style="bold")
comp_text.append(desc, style="bold")
else:
comp_text.append(" ", style="#888888")
comp_text.append(f"{cmd:<22}", 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:
cmd, _, arg = command.strip().partition(" ")
cmd = cmd.lower()
arg = arg.strip()
if cmd in ("/exit", "/quit", "/q"):
self.action_request_quit()
return
if cmd == "/help":
help_text = Text("Available commands:\n", style="bold")
for hcmd, hdesc in _TUI_SLASH_COMMANDS:
help_text.append(f" {hcmd:<22}", style="cyan")
help_text.append(f"{hdesc}\n", style="dim")
self._mount_renderable(help_text)
return
if cmd == "/current":
from .. import paths
self._append_system(f"Thread: {self._thread_id}", style="dim")
if self._workspace_dir:
self._append_system(
f"Workspace: {_shorten_path(self._workspace_dir)}",
style="dim",
)
memory_path = _shorten_path(str(paths.MEMORY_DIR))
if memory_path:
self._append_system(f"Memory dir: {memory_path}", style="dim")
self._append_system("UI: textual", style="dim")
return
if cmd == "/new":
# Clear all widgets except #welcome
container = self.query_one("#chat", VerticalScroll)
welcome = self.query_one("#welcome", Static)
for child in list(container.children):
if child is not welcome:
await child.remove()
if not workspace_fixed:
self._workspace_dir = create_session_workspace(run_name)
self._thread_id = generate_thread_id()
self._agent = load_agent(
workspace_dir=self._workspace_dir,
checkpointer=self._checkpointer,
)
if _channels_is_running():
_ch_mod._cli_agent = self._agent
_ch_mod._cli_thread_id = self._thread_id
self._render_welcome()
self._render_status()
self._append_system(f"New session: {self._thread_id}", style="green")
return
if cmd == "/clear":
container = self.query_one("#chat", VerticalScroll)
welcome = self.query_one("#welcome", Static)
for child in list(container.children):
if child is not welcome:
await child.remove()
return
if cmd == "/threads":
await self._cmd_threads()
return
if cmd == "/resume":
await self._cmd_resume(arg)
return
if cmd == "/delete":
await self._cmd_delete(arg)
return
if cmd == "/skills":
self._cmd_skills()
return
if cmd == "/install-skill":
self._cmd_install_skill(arg)
return
if cmd == "/uninstall-skill":
self._cmd_uninstall_skill(arg)
return
if cmd == "/mcp":
self._cmd_mcp(arg)
return
if cmd == "/channel":
self._cmd_channel(arg)
return
self._append_system(f"Unknown command: {command}", style="yellow")
async def _resolve_thread_id(self, prefix: str) -> str | None:
if await thread_exists(prefix):
return prefix
similar = await find_similar_threads(prefix)
if len(similar) == 1:
return similar[0]
if len(similar) > 1:
self._append_system(
f"Ambiguous thread ID '{prefix}'. Use a longer prefix.",
style="yellow",
)
for thread in similar:
self._append_system(f" - {thread}", style="dim")
return None
self._append_system(f"Thread '{prefix}' not found.", style="red")
return None
async def _cmd_threads(self) -> None:
threads = await list_threads(
limit=0,
include_message_count=True,
include_preview=True,
)
if not threads:
self._append_system("No saved sessions.", style="yellow")
return
table = Table(title="Sessions", show_header=True, header_style="bold cyan")
table.add_column("ID", style="bold")
table.add_column("Preview", style="dim", max_width=50, no_wrap=True)
table.add_column("Messages", justify="right")
table.add_column("Model", style="dim")
table.add_column("Last Used", style="dim")
for thread in threads:
thread_id_value = thread["thread_id"]
marker = " *" if thread_id_value == self._thread_id else ""
table.add_row(
f"{thread_id_value}{marker}",
thread.get("preview", "") or "",
str(thread.get("message_count", 0)),
thread.get("model", "") or "",
_format_relative_time(thread.get("updated_at")),
)
self._mount_renderable(table)
async def _render_history(self, thread_id_value: str) -> None:
"""Render conversation history from a saved thread."""
messages = await get_thread_messages(thread_id_value)
if not messages:
return
container = self.query_one("#chat", VerticalScroll)
await container.mount(SystemMessage("── Conversation history ──", msg_style="dim"))
for message in messages:
msg_type = getattr(message, "type", None)
content = getattr(message, "content", "") or ""
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 len(content) > 220:
content = content[:220] + "..."
if msg_type == "human":
await container.mount(UserMessage(content))
elif msg_type == "ai":
tool_calls = getattr(message, "tool_calls", None) or []
if content:
await container.mount(
Static(Text(content, style="dim"))
)
if tool_calls:
names = [tc.get("name", "?") for tc in tool_calls]
await container.mount(
Static(Text(f" \u25b6 {', '.join(names)}", style="dim italic"))
)
await container.mount(SystemMessage("── End of history ──", msg_style="dim"))
container.scroll_end(animate=False)
async def _cmd_resume(self, arg: str) -> None:
if not arg:
self._append_system("Usage: /resume <thread-id-prefix>", style="yellow")
await self._cmd_threads()
return
resolved = await self._resolve_thread_id(arg)
if not resolved:
return
metadata = await get_thread_metadata(resolved)
restored_workspace = (metadata or {}).get("workspace_dir", "")
if restored_workspace:
self._workspace_dir = restored_workspace
self._thread_id = resolved
self._agent = load_agent(
workspace_dir=self._workspace_dir,
checkpointer=self._checkpointer,
)
if _channels_is_running():
_ch_mod._cli_agent = self._agent
_ch_mod._cli_thread_id = self._thread_id
self._render_welcome()
self._render_status()
self._append_system(f"Resumed session: {resolved}", style="green")
await self._render_history(resolved)
async def _cmd_delete(self, arg: str) -> None:
if not arg:
self._append_system("Usage: /delete <thread-id-prefix>", style="yellow")
return
resolved = await self._resolve_thread_id(arg)
if not resolved:
return
if resolved == self._thread_id:
self._append_system(
"Cannot delete the current session.",
style="yellow",
)
return
deleted = await delete_thread(resolved)
if deleted:
self._append_system(f"Deleted session {resolved}.", style="green")
else:
self._append_system(f"Session {resolved} not found.", style="red")
def _cmd_skills(self) -> None:
from ..tools.skills_manager import list_skills
from ..paths import USER_SKILLS_DIR
skills = list_skills(include_system=True)
if not skills:
self._append_system("No skills available.", style="dim")
self._append_system("Install with: /install-skill <path-or-url>", style="dim")
self._append_system(f"Skills directory: {_shorten_path(str(USER_SKILLS_DIR))}", style="dim")
return
user_skills = [s for s in skills if s.source == "user"]
system_skills = [s for s in skills if s.source == "system"]
if user_skills:
table = Table(title=f"User Skills ({len(user_skills)})", show_header=True)
table.add_column("Name", style="green")
table.add_column("Description", style="dim")
for s in user_skills:
table.add_row(s.name, s.description)
self._mount_renderable(table)
if system_skills:
table = Table(title=f"Built-in Skills ({len(system_skills)})", show_header=True)
table.add_column("Name", style="cyan")
table.add_column("Description", style="dim")
for s in system_skills:
table.add_row(s.name, s.description)
self._mount_renderable(table)
self._append_system(
f"User skills folder: {_shorten_path(str(USER_SKILLS_DIR))}",
style="dim",
)
def _cmd_install_skill(self, source: str) -> None:
from ..tools.skills_manager import install_skill
if not source:
self._append_system("Usage: /install-skill <path-or-url>", style="yellow")
self._append_system("Examples:", style="dim")
self._append_system(" /install-skill ./my-skill", style="dim")
self._append_system(
" /install-skill https://github.com/user/repo/tree/main/skill-name",
style="dim",
)
self._append_system(" /install-skill user/repo@skill-name", style="dim")
return
self._append_system(f"Installing skill from: {source}", style="dim")
result = install_skill(source)
if result["success"]:
self._append_system(f"Installed: {result['name']}", style="green")
self._append_system(
f"Description: {result.get('description', '(none)')}",
style="dim",
)
self._append_system(f"Path: {_shorten_path(result['path'])}", style="dim")
self._append_system("Reload with /new to apply.", style="dim")
else:
self._append_system(f"Failed: {result['error']}", style="red")
def _cmd_uninstall_skill(self, name: str) -> None:
from ..tools.skills_manager import uninstall_skill
if not name:
self._append_system("Usage: /uninstall-skill <skill-name>", style="yellow")
self._append_system("Use /skills to see installed skills.", style="dim")
return
result = uninstall_skill(name)
if result["success"]:
self._append_system(f"Uninstalled: {name}", style="green")
self._append_system("Reload with /new to apply.", style="dim")
else:
self._append_system(f"Failed: {result['error']}", style="red")
def _cmd_mcp(self, args: str) -> None:
args = args.strip()
if not args or args == "list":
self._mcp_list()
return
parts = args.split(maxsplit=1)
subcmd = parts[0].lower()
subargs = parts[1] if len(parts) > 1 else ""
if subcmd == "config":
self._mcp_config(subargs.strip())
elif subcmd == "add":
self._mcp_add(subargs)
elif subcmd == "edit":
self._mcp_edit(subargs)
elif subcmd == "remove":
self._mcp_remove(subargs.strip())
else:
self._append_system("MCP commands:", style="bold")
self._append_system(" /mcp List configured servers", style="dim")
self._append_system(" /mcp list List configured servers", style="dim")
self._append_system(" /mcp config Show detailed server config", style="dim")
self._append_system(" /mcp add ... Add a server", style="dim")
self._append_system(" /mcp edit ... Edit an existing server", style="dim")
self._append_system(" /mcp remove ... Remove a server", style="dim")
def _mcp_list(self) -> None:
from ..mcp import load_mcp_config
from ..mcp.client import USER_MCP_CONFIG
config = load_mcp_config()
if not config:
self._append_system("No MCP servers configured.", style="dim")
self._append_system("Add one with: /mcp add <name> <command-or-url> [args...]", style="dim")
return
table = Table(title="MCP Servers", show_header=True)
table.add_column("Server", style="cyan")
table.add_column("Transport", style="green")
table.add_column("Tools", style="yellow")
table.add_column("Expose To", style="magenta")
for name, server in config.items():
transport = server.get("transport", "?")
tools = server.get("tools")
tools_str = ", ".join(tools) if tools else "(all)"
expose_to = server.get("expose_to", ["main"])
if isinstance(expose_to, str):
expose_to = [expose_to]
expose_str = ", ".join(expose_to)
table.add_row(name, transport, tools_str, expose_str)
self._mount_renderable(table)
self._append_system(f"Config file: {USER_MCP_CONFIG}", style="dim")
def _mcp_config(self, name: str) -> None:
from ..mcp import load_mcp_config
from ..mcp.client import USER_MCP_CONFIG
config = load_mcp_config()
if not config:
self._append_system("No MCP servers configured.", style="dim")
return
if name and name not in config:
self._append_system(f"Server not found: {name}", style="red")
return
servers = {name: config[name]} if name else config
for srv_name, srv in servers.items():
table = Table(title=f"MCP Server: {srv_name}", show_header=True, title_style="bold cyan")
table.add_column("Setting", style="cyan")
table.add_column("Value")
table.add_row("transport", str(srv.get("transport", "(not set)")))
if srv.get("command"):
table.add_row("command", str(srv["command"]))
if srv.get("args"):
table.add_row("args", " ".join(str(a) for a in srv["args"]))
if srv.get("url"):
table.add_row("url", str(srv["url"]))
if srv.get("headers"):
for k, v in srv["headers"].items():
table.add_row(f"header: {k}", str(v))
if srv.get("env"):
for k, v in srv["env"].items():
table.add_row(f"env: {k}", str(v))
tools = srv.get("tools")
table.add_row("tools", ", ".join(tools) if tools else "(all)")
expose_to = srv.get("expose_to", ["main"])
if isinstance(expose_to, str):
expose_to = [expose_to]
table.add_row("expose_to", ", ".join(expose_to))
self._mount_renderable(table)
self._append_system(f"Config file: {USER_MCP_CONFIG}", style="dim")
def _mcp_add(self, args_str: str) -> None:
from ..mcp import parse_mcp_add_args, add_mcp_server
if not args_str.strip():
self._append_system("Usage: /mcp add <name> <command-or-url> [args...]", style="yellow")
return
try:
tokens = shlex.split(args_str)
kwargs = parse_mcp_add_args(tokens)
entry = add_mcp_server(**kwargs)
self._append_system(
f"Added MCP server: {kwargs['name']} ({entry['transport']})",
style="green",
)
self._append_system("Reload with /new to apply.", style="dim")
except ValueError as exc:
self._append_system(f"{exc}", style="red")
def _mcp_edit(self, args_str: str) -> None:
from ..mcp import parse_mcp_edit_args, edit_mcp_server
if not args_str.strip():
self._append_system(
"Usage: /mcp edit <name> --<field> <value> ...",
style="yellow",
)
return
try:
tokens = shlex.split(args_str)
name, fields = parse_mcp_edit_args(tokens)
if not fields:
self._append_system(
"No fields to edit. Use --transport, --command, --url, --tools, --expose-to, etc.",
style="red",
)
return
edit_mcp_server(name, **fields)
self._append_system(f"Updated MCP server: {name}", style="green")
for k, v in fields.items():
self._append_system(f" {k}: {v}", style="dim")
self._append_system("Reload with /new to apply.", style="dim")
except (KeyError, ValueError) as exc:
self._append_system(f"{exc}", style="red")
def _mcp_remove(self, name: str) -> None:
from ..mcp import remove_mcp_server
if not name:
self._append_system("Usage: /mcp remove <name>", style="yellow")
return
if remove_mcp_server(name):
self._append_system(f"Removed MCP server: {name}", style="green")
self._append_system("Reload with /new to apply.", style="dim")
else:
self._append_system(f"Server not found: {name}", style="red")
def _cmd_channel(self, args: str) -> None:
"""Handle /channel command — start, stop, or show status."""
from ..config import load_config
from .channel import (
_add_channel_to_running_bus,
_start_channels_bus_mode,
_channels_running_list,
)
args = args.strip().lower() if args else ""
if args == "status" or (not args and _channels_is_running()):
running = _channels_running_list()
if running and _ch_mod._manager:
detailed = _ch_mod._manager.get_detailed_status()
table = Table(
title="Channel Status", show_header=True, expand=False,
)
table.add_column("Channel", style="cyan")
table.add_column("Status")
table.add_column("Uptime", style="dim")
table.add_column("Rx", justify="right")
table.add_column("Tx", justify="right")
for ch_name in running:
info = detailed.get(ch_name, {})
secs = info.get("uptime_seconds", 0)
mins, s = divmod(int(secs), 60)
hours, mins = divmod(mins, 60)
uptime = (
f"{hours}h{mins:02d}m" if hours else f"{mins}m{s:02d}s"
)
rx = str(info.get("received", 0))
tx = str(info.get("sent", 0))
table.add_row(
ch_name, "[green]running[/green]", uptime, rx, tx,
)
self._mount_renderable(table)
else:
self._append_system("No channel running", style="dim")
return
if args.startswith("stop"):
stop_type = args[len("stop"):].strip() or None
if not _channels_is_running():
self._append_system("No channel running", style="dim")
return
if stop_type:
if not _channels_is_running(stop_type):
self._append_system(
f"{stop_type} is not running", style="dim",
)
return
_channels_stop(stop_type)
if stop_type in self._started_channel_types:
self._started_channel_types.remove(stop_type)
self._append_system(f"{stop_type} stopped", style="dim")
else:
running = _channels_running_list()
_channels_stop()
self._started_channel_types.clear()
self._append_system(
f"{', '.join(running)} stopped", style="dim",
)
self._render_welcome()
return
# Start channel(s)
app_config = load_config()
channel_type = args if args else (
app_config.channel_enabled if app_config else ""
)
if not channel_type:
self._append_system("No channel configured.", style="yellow")
self._append_system(
"Run EvoSci onboard or specify: /channel telegram",
style="dim",
)
return
requested = [
t.strip() for t in channel_type.split(",") if t.strip()
]
if _channels_is_running():
running = _channels_running_list()
results: list[tuple[str, bool, str]] = []
for ct in requested:
if ct in running:
results.append((ct, True, "already running"))
else:
try:
_add_channel_to_running_bus(
ct,
app_config,
send_thinking=self._channel_send_thinking,
)
results.append((ct, True, "connected (bus)"))
except Exception as e:
results.append((ct, False, str(e)))
else:
_ch_mod._cli_agent = self._agent
_ch_mod._cli_thread_id = self._thread_id
original = app_config.channel_enabled
app_config.channel_enabled = channel_type
try:
_start_channels_bus_mode(
app_config,
self._agent,
self._thread_id,
send_thinking=self._channel_send_thinking,
)
results = [
(ct, True, "connected (bus)") for ct in requested
]
except Exception as e:
results = [(ct, False, str(e)) for ct in requested]
finally:
app_config.channel_enabled = original
for ct, ok, _ in results:
if ok and ct not in self._started_channel_types:
self._started_channel_types.append(ct)
self._render_channel_results(results)
self._render_welcome()
def _render_channel_results(
self, results: list[tuple[str, bool, str]],
) -> None:
for name, ok, detail in results:
if ok:
self._append_system(
f"\u25cf {name} {detail}", style="green",
)
else:
self._append_system(
f"\u2717 {name} {detail}", style="yellow",
)
# ── Quit handling ──────────────────────────────────────
def action_request_quit(self) -> None:
if self._busy:
if self._run_task is not None and not self._run_task.done():
self._run_task.cancel()
self._append_system("Interrupted.", style="yellow")
else:
self._busy = False
prompt = self.query_one("#prompt", Input)
prompt.disabled = False
prompt.focus()
self._render_status()
self._append_system("Interrupted.", style="yellow")
return
# Clean up channels
if self._channel_timer is not None:
self._channel_timer.stop()
self._channel_timer = None
self._started_channel_types.clear()
if _channels_is_running():
try:
_channels_stop()
except Exception:
pass
self.exit()
# ── Banner & status ────────────────────────────────────
def _render_welcome(self) -> None:
channels_info: list[tuple[str, bool, str]] | None = None
try:
running = _channels_running_list()
started = self._started_channel_types
if running or started:
all_types = list(dict.fromkeys(running + started))
channels_info = [
(ct, True, "connected (bus)") for ct in all_types
]
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._thread_id,
workspace_dir=self._workspace_dir,
mode=mode,
model=model,
provider=provider,
ui_backend="textual",
channels=channels_info,
)
)
def _render_status(self) -> None:
status = self.query_one("#status", Static)
if self._busy:
left = "vibe researching..."
left_style = "bold #f59e0b"
else:
left = "/help for commands"
left_style = "#f59e0b"
status.update(
Text.assemble(
(left, left_style),
(" ", ""),
("EvoScientist", "dim"),
)
)
# ── 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 = thread_id
resumed = False
resume_warning = ""
if thread_id:
if await thread_exists(thread_id):
resolved = thread_id
else:
similar = await find_similar_threads(thread_id)
resolved = similar[0] if len(similar) == 1 else None
if resolved:
meta = await get_thread_metadata(resolved)
ws = (meta or {}).get("workspace_dir", "")
if ws:
effective_workspace = ws
effective_thread_id = resolved
resumed = True
else:
resume_warning = (
f"Thread '{thread_id}' not found. Starting new session."
)
if not effective_thread_id:
effective_thread_id = generate_thread_id()
initial_agent = load_agent(
workspace_dir=effective_workspace,
checkpointer=checkpointer,
)
app = EvoTextualInteractiveApp(
agent=initial_agent,
thread_id_value=effective_thread_id,
workspace=effective_workspace,
checkpointer=checkpointer,
channel_send_thinking_value=channel_send_thinking,
resumed=resumed,
resume_warning=resume_warning,
)
await app.run_async()
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())