diff --git a/src/tether/__init__.py b/src/tether/__init__.py index 06d2af8..7ad2867 100644 --- a/src/tether/__init__.py +++ b/src/tether/__init__.py @@ -1,6 +1,7 @@ """Provider-neutral Agent integration and the owner-bound Client composition.""" from tether.client import Client +from tether.client._composition.client import BoundClient from tether.sessions.service import SessionService from tether.types import MODEL_PORT_VERSION as MODEL_PORT_VERSION from tether.types.execution import Actor @@ -10,4 +11,4 @@ class Tether(SessionService): """Explicit asynchronous composition; public commands are developed in slice 4.""" def client(self, actor: Actor) -> Client: - return Client(self, actor) + return BoundClient(self, actor) diff --git a/src/tether/client/_composition/client.py b/src/tether/client/_composition/client.py index 41579e7..55dfae6 100644 --- a/src/tether/client/_composition/client.py +++ b/src/tether/client/_composition/client.py @@ -125,10 +125,10 @@ async def turn_result(self, session_id: str, turn_id: str) -> TurnResult | None: class Client(ClientTurnOperations, OperationClient, ClientReads): - def __init__(self, service: SessionService, actor: Actor) -> None: - super().__init__(service.access, actor, service.archives) - self._service = service - self._metadata = MetadataCommands(service.access) + _metadata: MetadataCommands + + def __init__(self) -> None: + raise TypeError("Obtain a Client through ClientHost.client(actor)") async def confirm( self, @@ -212,3 +212,12 @@ async def resume(self, session_id: str) -> TurnHandle: async def restore(self, session_id: str) -> SessionSummary: return await self._service.archives.restore(self._actor, session_id) + + +class BoundClient(Client): + """Internal implementation constructed with an owner-bound service.""" + + def __init__(self, service: SessionService, actor: Actor) -> None: + ClientReads.__init__(self, service.access, actor, service.archives) + self._service = service + self._metadata = MetadataCommands(service.access) diff --git a/src/tether/client/_composition/host.py b/src/tether/client/_composition/host.py index f473e18..bd2d73d 100644 --- a/src/tether/client/_composition/host.py +++ b/src/tether/client/_composition/host.py @@ -84,9 +84,18 @@ class ClientPorts: class ClientHost: """Owns a composed client service and only the resources it opens.""" - def __init__(self, service: SessionService) -> None: - self._service = service - self._closed = False + _service: SessionService + _closed: bool + + def __init__(self) -> None: + raise TypeError("Use ClientHost.open() or ClientHost.from_ports()") + + @classmethod + def _from_service(cls, service: SessionService) -> Self: + host = cls.__new__(cls) + host._service = service + host._closed = False + return host @classmethod async def open(cls, settings: ClientSettings) -> Self: @@ -154,7 +163,7 @@ async def _open(cls, settings: ClientSettings, ports: ClientPorts) -> Self: _storage_drain=root.wait_closed if root is not None else None, ) await service.__aenter__() - return cls(service) + return cls._from_service(service) except BaseException: if service is not None: await service.aclose() @@ -170,9 +179,9 @@ async def _open(cls, settings: ClientSettings, ports: ClientPorts) -> Self: def client(self, actor: Actor) -> ClientProtocol: if self._closed: raise RuntimeError("tether_not_active") - from .client import Client + from .client import BoundClient - return Client(self._service, actor) + return BoundClient(self._service, actor) @property def store(self) -> SessionStore: diff --git a/src/tether/tui/__init__.py b/src/tether/tui/__init__.py index a1cac22..0b2ea50 100644 --- a/src/tether/tui/__init__.py +++ b/src/tether/tui/__init__.py @@ -1,484 +1,21 @@ -"""Textual reference UI for the offline, single-owner local demo profile.""" +"""Textual client UI and lazy compatibility exports for the local demo.""" -from __future__ import annotations +from typing import TYPE_CHECKING -import asyncio -import json -from contextlib import suppress -from pathlib import Path -from typing import Any, ClassVar -from uuid import uuid4 +from ._presentation import ClientApp as ClientApp -from textual.app import App, ComposeResult -from textual.containers import Horizontal, Vertical -from textual.widgets import ( - Button, - Footer, - Header, - Input, - Label, - ListItem, - ListView, - RichLog, - Static, -) +if TYPE_CHECKING: + from ._demo import DemoApp as DemoApp + from ._demo import run as run -from tether.cli.demo import LocalModelOptions, ReferenceModelProfile, open_demo, resolve_profile -from tether.client import ( - Actor, - Answer, - ClientProtocol, - ReplyReset, - ReplyText, - SessionSnapshot, - SessionSummary, -) -from tether.client import ( - SessionUpdated as SessionUpdated, -) -from .feed import FeedPresentation, follow_client -from .terminal import terminal_notice +def __getattr__(name: str) -> object: + if name == "DemoApp": + from ._demo import DemoApp + return DemoApp + if name == "run": + from ._demo import run -class DemoApp(App[None]): - TITLE = "Tether · offline demo" - BINDINGS: ClassVar = [("ctrl+n", "new_session", "New session")] - CSS = """ - #session-panel { width: 28; } - #new-session { width: 1fr; } - #sessions { width: 1fr; height: 1fr; border: solid $primary; } - #conversation { width: 1fr; border: solid $primary; } - #transcript { height: 1fr; } - #reply { height: auto; max-height: 50%; padding: 0 1; - border-top: solid $primary; overflow-y: auto; display: none; } - #message { width: 1fr; } - #controls { height: 3; } - #body { height: 1fr; } - """ - - def __init__( - self, - root: Path | None = None, - *, - client: ClientProtocol | None = None, - session_id: str | None = None, - volatile: bool = False, - model_config: Path | None = None, - local_options: LocalModelOptions | None = None, - ) -> None: - super().__init__() - self.root = root - self.volatile = volatile - self.model_config = model_config - self.local_options = local_options - self._demo_context: Any = None - self._injected_client = client - self._initial_session_id = session_id - self.client: ClientProtocol | None = None - self.actor: Actor | None = None - self.session_id: str | None = None - self.sessions: tuple[SessionSummary, ...] = () - self._follower: asyncio.Task[None] | None = None - self._follower_stopping: asyncio.Event | None = None - self._reply_turn: str | None = None - self._reply_attempt: str | None = None - self._reply_text = "" - self._render_generation = 0 - - def compose(self) -> ComposeResult: - yield Header() - yield Static("Live updates enabled", id="connection", markup=False) - with Horizontal(id="body"): - with Vertical(id="session-panel"): - yield Button("New Session", id="new-session") - yield ListView(id="sessions") - with Vertical(id="conversation"): - yield RichLog(id="transcript", wrap=True, markup=False) - yield Static(id="reply", markup=False) - with Vertical(id="controls"), Horizontal(): - yield Input(placeholder="Send a fabricated message", id="message") - yield Button("Send", id="send") - yield Button("Approve", id="approve") - yield Button("Deny", id="deny") - yield Button("Resume", id="resume") - yield Footer() - - async def on_mount(self) -> None: - if self._injected_client is not None: - self.title = "Tether · client" - self.client = self._injected_client - await self._connect_client(self._initial_session_id) - return - if self.root is None: - raise ValueError("demo_root_required") - profile = await resolve_profile(self.model_config, self.local_options) - if profile is not None and profile.available_models: - from .model_picker import ModelPicker - - async def selected(name: str | None) -> None: - if name is None: - self.exit() - return - await self._connect( - profile.model_copy(update={"model_name": name, "available_models": ()}) - ) - - self.push_screen(ModelPicker(profile.available_models), selected) - return - await self._connect(profile) - - async def _connect(self, profile: ReferenceModelProfile | None) -> None: - if self.root is None: - raise ValueError("demo_root_required") - if profile is not None: - self.title = "Tether · " + profile.id - if self.local_options is not None: - self.sub_title = profile.model_name - self.query_one("#message", Input).placeholder = "Send a message" - self._demo_context = open_demo(self.root, volatile=self.volatile, profile=profile) - app, actor, _ = await self._demo_context.__aenter__() - client = app.client(actor) - self.client, self.actor = client, actor - session_ref = profile.session_ref if profile is not None else "demo" - demo = await client.find(session_ref) - if demo is None: - demo = await client.create( - ref=session_ref, - title="Model · " + profile.id if profile is not None else "Offline demo", - settings={"approval": "manual"}, - ) - self.session_id = demo.id - await self._connected(profile) - - async def _connect_client(self, session_id: str | None) -> None: - client = self.client - if client is None: - raise RuntimeError("client_not_connected") - if session_id is not None: - await client.get(session_id) - self.session_id = session_id - else: - page = await client.list() - self.session_id = page.items[0].id if page.items else None - if self.session_id is None: - created = await client.create(title="Session") - self.session_id = created.id - await self._connected(None) - - async def _connected(self, profile: ReferenceModelProfile | None) -> None: - snapshot = ( - await self.client.snapshot(self.session_id) - if self.client is not None and self.session_id is not None - else None - ) - await self._refresh_sessions() - await self._show_session() - if self.local_options is not None: - self.query_one("#transcript", RichLog).write( - f"Connected model: {profile.model_name if profile else 'local'}. " - f"Context budget: {profile.context_window_tokens if profile else 0} " - f"({profile.context_source if profile else 'starter'}); approximate byte estimate. " - "Tools use the selected workspace and require approval." - ) - self._start_follower(snapshot.seq if snapshot is not None else None) - self.query_one("#message", Input).focus() - - def _start_follower(self, initial_cursor: int | None) -> None: - stopping = asyncio.Event() - self._follower_stopping = stopping - self._follower = asyncio.create_task(self._follow(initial_cursor, stopping)) - - async def action_new_session(self) -> None: - if self.client is None: - return - # Clear the old draft before switching: text typed once the new session - # is selected belongs to it and must survive the refresh below. - field = self.query_one("#message", Input) - field.value = "" - session = await self.client.create( - title="Session · " + uuid4().hex[:8], settings={"approval": "manual"} - ) - self.session_id = session.id - await self._refresh_sessions() - await self._show_session() - field.focus() - - async def _stop_follower(self) -> None: - if self._follower_stopping is not None: - self._follower_stopping.set() - if self._follower is not None: - self._follower.cancel() - with suppress(asyncio.CancelledError): - await self._follower - self._follower = None - self._follower_stopping = None - - async def action_quit(self) -> None: - await self._stop_follower() - await super().action_quit() - - async def on_unmount(self) -> None: - await self._stop_follower() - if self._demo_context is not None: - await self._demo_context.__aexit__(None, None, None) - - async def _refresh_sessions(self) -> None: - if self.client is None or not self.is_running: - return - page = await self.client.list() - if not self.is_running: - return - self.sessions = page.items - listing = next((node for node in self.query(ListView) if node.id == "sessions"), None) - if listing is None: - return - await listing.clear() - for item in page.items: - if not self.is_running: - return - await listing.append(ListItem(Label(f"{item.title or item.id} · {item.status}"))) - if not self.is_running: - return - listing.index = next( - (index for index, item in enumerate(self.sessions) if item.id == self.session_id), None - ) - - async def _show_session(self) -> None: - client, selected = self.client, self.session_id - if client is None or selected is None or not self.is_running: - return - self._render_generation += 1 - generation = self._render_generation - self._reply_turn = None - self._reset_reply() - log = self.query_one("#transcript", RichLog) - log.clear() - snapshot = await client.snapshot(selected) - if not self._view_is_current(selected, generation): - return - await self._render_history(client, selected, snapshot.through_index, generation) - if not self._view_is_current(selected, generation): - return - await self._update_approval(selected, generation) - if not self._view_is_current(selected, generation): - return - await self._render_terminal_notice(client, selected, snapshot, generation) - - def _view_is_current(self, session_id: str, generation: int) -> bool: - return ( - self.is_running - and (self._follower_stopping is None or not self._follower_stopping.is_set()) - and self.session_id == session_id - and self._render_generation == generation - ) - - async def _render_history( - self, client: ClientProtocol, session_id: str, through_index: int, generation: int - ) -> None: - start = 0 - while True: - page = await client.history(session_id, start=start) - if not self._view_is_current(session_id, generation): - return - for slot in page.items: - if slot.entry_index > through_index: - continue - record = slot.value - if record.status == "ready" and record.record is not None: - message = record.record.message - if message is not None and message.content: - self.query_one("#transcript", RichLog).write( - f"{message.role}: {message.content}" - ) - elif record.status != "ready": - self.query_one("#transcript", RichLog).write( - f"[history {record.status} at {slot.entry_index}]" - ) - if page.next_start is None: - return - start = page.next_start - - async def _render_terminal_notice( - self, - client: ClientProtocol, - session_id: str, - snapshot: SessionSnapshot, - generation: int, - ) -> None: - notice = await terminal_notice( - client, - session_id, - snapshot, - current=lambda: self._view_is_current(session_id, generation), - ) - if not self._view_is_current(session_id, generation): - return - latest = await client.snapshot(session_id) - if ( - self._view_is_current(session_id, generation) - and latest.through_index == snapshot.through_index - and notice is not None - ): - self.query_one("#transcript", RichLog).write(notice) - - async def _update_approval(self, session_id: str, generation: int) -> None: - client = self.client - if client is None: - return - pending = await client.pending(session_id) - if not self._view_is_current(session_id, generation): - return - view = await client.get(session_id) - if not self._view_is_current(session_id, generation): - return - self.query_one("#approve", Button).disabled = pending is None or pending.arguments is None - self.query_one("#deny", Button).disabled = pending is None - self.query_one("#resume", Button).disabled = not view.summary.resumable - if pending is not None: - self.query_one("#transcript", RichLog).write( - f"Approval requested: {pending.tool} — {pending.description}" - ) - self.query_one("#transcript", RichLog).write( - json.dumps(pending.arguments, ensure_ascii=True) - if pending.arguments is not None - else "[arguments unavailable]" - ) - - def _reset_reply(self) -> None: - self._reply_attempt = None - self._reply_text = "" - if not self.is_running: - return - reply = self.query_one("#reply", Static) - reply.update("") - reply.display = False - - def _update_reply(self, change: ReplyText) -> None: - if change.session_id != self.session_id or change.turn_id != self._reply_turn: - return - if change.attempt_id != self._reply_attempt: - self._reset_reply() - if change.offset != 0: - return - self._reply_attempt = change.attempt_id - if len(self._reply_text) != change.offset: - self._reset_reply() - return - self._reply_text += change.text - reply = self.query_one("#reply", Static) - reply.border_title = "Assistant · responding" - reply.update(self._reply_text + " ▍") - reply.display = True - reply.call_after_refresh(reply.scroll_end, animate=False) - - async def _follow( - self, - initial_cursor: int | None = None, - stopping: asyncio.Event | None = None, - ) -> None: - if self.client is None: - return - if stopping is None: - stopping = asyncio.Event() - self._follower_stopping = stopping - - def reset_attempt(change: ReplyReset) -> None: - if ( - change.session_id == self.session_id - and change.turn_id == self._reply_turn - and change.attempt_id == self._reply_attempt - ): - self._reset_reply() - - def failed() -> None: - if self.is_running: - self.query_one("#connection", Static).update( - "Live updates unavailable. Reopen the client to reconnect." - ) - - await follow_client( - self.client, - FeedPresentation( - selected=lambda: self.session_id, - refresh=self._refresh_sessions, - show=self._show_session, - reset=self._reset_reply, - reply=self._update_reply, - reset_attempt=reset_attempt, - failed=failed, - busy=lambda: self._reply_turn is not None, - stopping=stopping.is_set, - ), - initial_cursor=initial_cursor, - ) - - async def _send(self) -> None: - if self.client is None or self.session_id is None: - return - field = self.query_one("#message", Input) - value = field.value.strip() - if not value: - return - field.value = "" - self.query_one("#transcript", RichLog).write(f"user: {value}") - await self._finish(await self.client.send(self.session_id, value)) - - async def _finish(self, handle: Any) -> None: - selected = self.session_id - self._reply_turn = handle.turn_id - try: - await handle.result() - finally: - self._reply_turn = None - self._reset_reply() - await self._refresh_sessions() - if self.is_running and self.session_id == selected: - await self._show_session() - - async def on_input_submitted(self, event: Input.Submitted) -> None: - if event.input.id == "message": - await self._send() - - async def on_button_pressed(self, event: Button.Pressed) -> None: - if self.client is None or self.session_id is None: - return - if event.button.id == "new-session": - await self.action_new_session() - elif event.button.id == "send": - await self._send() - elif event.button.id in {"approve", "deny"}: - pending = await self.client.pending(self.session_id) - if pending is not None: - handle = await self.client.confirm( - self.session_id, - pending.invocation_id, - Answer(approved=event.button.id == "approve"), - ) - if handle is not None: - await self._finish(handle) - elif event.button.id == "resume": - await self._finish(await self.client.resume(self.session_id)) - - async def on_list_view_selected(self, event: ListView.Selected) -> None: - index = event.list_view.index - if index is not None and index < len(self.sessions): - self.session_id = self.sessions[index].id - await self._show_session() - - -def run( - root: Path, - *, - volatile: bool = False, - model_config: Path | None = None, - local_options: LocalModelOptions | None = None, -) -> None: - DemoApp(root, volatile=volatile, model_config=model_config, local_options=local_options).run() - - -class ClientApp(DemoApp): - """Textual client UI that borrows an embedded or remote client.""" - - def __init__(self, client: ClientProtocol, *, session_id: str | None = None) -> None: - super().__init__(client=client, session_id=session_id) + return run + raise AttributeError(name) diff --git a/src/tether/tui/_demo.py b/src/tether/tui/_demo.py new file mode 100644 index 0000000..9acabaf --- /dev/null +++ b/src/tether/tui/_demo.py @@ -0,0 +1,106 @@ +"""Composition and resource ownership for the local terminal demo.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +from textual.widgets import Input + +from tether.cli.demo import LocalModelOptions, ReferenceModelProfile, open_demo, resolve_profile +from tether.client import Actor, ClientProtocol + +from ._presentation import SessionApp + + +class DemoApp(SessionApp): + TITLE = "Tether · offline demo" + + def __init__( + self, + root: Path | None = None, + *, + client: ClientProtocol | None = None, + session_id: str | None = None, + volatile: bool = False, + model_config: Path | None = None, + local_options: LocalModelOptions | None = None, + ) -> None: + super().__init__(client, session_id=session_id) + self.root = root + self.volatile = volatile + self.model_config = model_config + self.local_options = local_options + self.actor: Actor | None = None + self._demo_context: Any = None + + async def on_mount(self) -> None: + if self.client is not None: + self.title = "Tether · client" + await self._connect_client(self._initial_session_id) + return + if self.root is None: + raise ValueError("demo_root_required") + profile = await resolve_profile(self.model_config, self.local_options) + if profile is not None and profile.available_models: + from .model_picker import ModelPicker + + async def selected(name: str | None) -> None: + if name is None: + self.exit() + return + await self._connect( + profile.model_copy(update={"model_name": name, "available_models": ()}) + ) + + self.push_screen(ModelPicker(profile.available_models), selected) + return + await self._connect(profile) + + async def _connect(self, profile: ReferenceModelProfile | None) -> None: + if self.root is None: + raise ValueError("demo_root_required") + if profile is not None: + self.title = "Tether · " + profile.id + if self.local_options is not None: + self.sub_title = profile.model_name + self.query_one("#message", Input).placeholder = "Send a message" + self._demo_context = open_demo(self.root, volatile=self.volatile, profile=profile) + app, actor, _ = await self._demo_context.__aenter__() + client = app.client(actor) + self.client, self.actor = client, actor + session_ref = profile.session_ref if profile is not None else "demo" + demo = await client.find(session_ref) + if demo is None: + demo = await client.create( + ref=session_ref, + title="Model · " + profile.id if profile is not None else "Offline demo", + settings={"approval": "manual"}, + ) + self.session_id = demo.id + notice = None + if self.local_options is not None: + notice = ( + f"Connected model: {profile.model_name if profile else 'local'}. " + f"Context budget: {profile.context_window_tokens if profile else 0} " + f"({profile.context_source if profile else 'starter'}); approximate byte estimate. " + "Tools use the selected workspace and require approval." + ) + await self._connected(notice=notice) + + async def on_unmount(self) -> None: + try: + await self._stop_follower() + finally: + if self._demo_context is not None: + await self._demo_context.__aexit__(None, None, None) + + +def run( + root: Path, + *, + volatile: bool = False, + model_config: Path | None = None, + local_options: LocalModelOptions | None = None, +) -> None: + DemoApp(root, volatile=volatile, model_config=model_config, local_options=local_options).run() diff --git a/src/tether/tui/_presentation.py b/src/tether/tui/_presentation.py new file mode 100644 index 0000000..3e8e522 --- /dev/null +++ b/src/tether/tui/_presentation.py @@ -0,0 +1,406 @@ +"""Textual reference UI for the offline, single-owner local demo profile.""" + +from __future__ import annotations + +import asyncio +import json +from contextlib import suppress +from typing import Any, ClassVar +from uuid import uuid4 + +from textual.app import App, ComposeResult +from textual.containers import Horizontal, Vertical +from textual.widgets import ( + Button, + Footer, + Header, + Input, + Label, + ListItem, + ListView, + RichLog, + Static, +) + +from tether.client import ( + Answer, + ClientProtocol, + ReplyReset, + ReplyText, + SessionSnapshot, + SessionSummary, +) +from tether.client import ( + SessionUpdated as SessionUpdated, +) + +from .feed import FeedPresentation, follow_client +from .terminal import terminal_notice + + +class SessionApp(App[None]): + """Textual presentation that borrows an embedded or remote client.""" + + TITLE = "Tether · client" + BINDINGS: ClassVar = [("ctrl+n", "new_session", "New session")] + CSS = """ + #session-panel { width: 28; } + #new-session { width: 1fr; } + #sessions { width: 1fr; height: 1fr; border: solid $primary; } + #conversation { width: 1fr; border: solid $primary; } + #transcript { height: 1fr; } + #reply { height: auto; max-height: 50%; padding: 0 1; + border-top: solid $primary; overflow-y: auto; display: none; } + #message { width: 1fr; } + #controls { height: 3; } + #body { height: 1fr; } + """ + + def __init__(self, client: ClientProtocol | None, *, session_id: str | None = None) -> None: + super().__init__() + self.client: ClientProtocol | None = client + self._initial_session_id = session_id + self.session_id: str | None = None + self.sessions: tuple[SessionSummary, ...] = () + self._follower: asyncio.Task[None] | None = None + self._follower_stopping: asyncio.Event | None = None + self._reply_turn: str | None = None + self._reply_attempt: str | None = None + self._reply_text = "" + self._render_generation = 0 + + def compose(self) -> ComposeResult: + yield Header() + yield Static("Live updates enabled", id="connection", markup=False) + with Horizontal(id="body"): + with Vertical(id="session-panel"): + yield Button("New Session", id="new-session") + yield ListView(id="sessions") + with Vertical(id="conversation"): + yield RichLog(id="transcript", wrap=True, markup=False) + yield Static(id="reply", markup=False) + with Vertical(id="controls"), Horizontal(): + yield Input(placeholder="Send a fabricated message", id="message") + yield Button("Send", id="send") + yield Button("Approve", id="approve") + yield Button("Deny", id="deny") + yield Button("Resume", id="resume") + yield Footer() + + async def _connect_client(self, session_id: str | None) -> None: + client = self.client + if client is None: + raise RuntimeError("client_not_connected") + if session_id is not None: + await client.get(session_id) + self.session_id = session_id + else: + page = await client.list() + self.session_id = page.items[0].id if page.items else None + if self.session_id is None: + created = await client.create(title="Session") + self.session_id = created.id + await self._connected() + + async def _connected(self, *, notice: str | None = None) -> None: + snapshot = ( + await self.client.snapshot(self.session_id) + if self.client is not None and self.session_id is not None + else None + ) + await self._refresh_sessions() + await self._show_session() + if notice is not None: + self.query_one("#transcript", RichLog).write(notice) + self._start_follower(snapshot.seq if snapshot is not None else None) + self.query_one("#message", Input).focus() + + def _start_follower(self, initial_cursor: int | None) -> None: + stopping = asyncio.Event() + self._follower_stopping = stopping + self._follower = asyncio.create_task(self._follow(initial_cursor, stopping)) + + async def action_new_session(self) -> None: + if self.client is None: + return + # Clear the old draft before switching: text typed once the new session + # is selected belongs to it and must survive the refresh below. + field = self.query_one("#message", Input) + field.value = "" + session = await self.client.create( + title="Session · " + uuid4().hex[:8], settings={"approval": "manual"} + ) + self.session_id = session.id + await self._refresh_sessions() + await self._show_session() + field.focus() + + async def _stop_follower(self) -> None: + if self._follower_stopping is not None: + self._follower_stopping.set() + if self._follower is not None: + self._follower.cancel() + with suppress(asyncio.CancelledError): + await self._follower + self._follower = None + self._follower_stopping = None + + async def action_quit(self) -> None: + await self._stop_follower() + await super().action_quit() + + async def on_unmount(self) -> None: + await self._stop_follower() + + async def _refresh_sessions(self) -> None: + if self.client is None or not self.is_running: + return + page = await self.client.list() + if not self.is_running: + return + self.sessions = page.items + listing = next((node for node in self.query(ListView) if node.id == "sessions"), None) + if listing is None: + return + await listing.clear() + for item in page.items: + if not self.is_running: + return + await listing.append(ListItem(Label(f"{item.title or item.id} · {item.status}"))) + if not self.is_running: + return + listing.index = next( + (index for index, item in enumerate(self.sessions) if item.id == self.session_id), None + ) + + async def _show_session(self) -> None: + client, selected = self.client, self.session_id + if client is None or selected is None or not self.is_running: + return + self._render_generation += 1 + generation = self._render_generation + self._reply_turn = None + self._reset_reply() + log = self.query_one("#transcript", RichLog) + log.clear() + snapshot = await client.snapshot(selected) + if not self._view_is_current(selected, generation): + return + await self._render_history(client, selected, snapshot.through_index, generation) + if not self._view_is_current(selected, generation): + return + await self._update_approval(selected, generation) + if not self._view_is_current(selected, generation): + return + await self._render_terminal_notice(client, selected, snapshot, generation) + + def _view_is_current(self, session_id: str, generation: int) -> bool: + return ( + self.is_running + and (self._follower_stopping is None or not self._follower_stopping.is_set()) + and self.session_id == session_id + and self._render_generation == generation + ) + + async def _render_history( + self, client: ClientProtocol, session_id: str, through_index: int, generation: int + ) -> None: + start = 0 + while True: + page = await client.history(session_id, start=start) + if not self._view_is_current(session_id, generation): + return + for slot in page.items: + if slot.entry_index > through_index: + continue + record = slot.value + if record.status == "ready" and record.record is not None: + message = record.record.message + if message is not None and message.content: + self.query_one("#transcript", RichLog).write( + f"{message.role}: {message.content}" + ) + elif record.status != "ready": + self.query_one("#transcript", RichLog).write( + f"[history {record.status} at {slot.entry_index}]" + ) + if page.next_start is None: + return + start = page.next_start + + async def _render_terminal_notice( + self, + client: ClientProtocol, + session_id: str, + snapshot: SessionSnapshot, + generation: int, + ) -> None: + notice = await terminal_notice( + client, + session_id, + snapshot, + current=lambda: self._view_is_current(session_id, generation), + ) + if not self._view_is_current(session_id, generation): + return + latest = await client.snapshot(session_id) + if ( + self._view_is_current(session_id, generation) + and latest.through_index == snapshot.through_index + and notice is not None + ): + self.query_one("#transcript", RichLog).write(notice) + + async def _update_approval(self, session_id: str, generation: int) -> None: + client = self.client + if client is None: + return + pending = await client.pending(session_id) + if not self._view_is_current(session_id, generation): + return + view = await client.get(session_id) + if not self._view_is_current(session_id, generation): + return + self.query_one("#approve", Button).disabled = pending is None or pending.arguments is None + self.query_one("#deny", Button).disabled = pending is None + self.query_one("#resume", Button).disabled = not view.summary.resumable + if pending is not None: + self.query_one("#transcript", RichLog).write( + f"Approval requested: {pending.tool} — {pending.description}" + ) + self.query_one("#transcript", RichLog).write( + json.dumps(pending.arguments, ensure_ascii=True) + if pending.arguments is not None + else "[arguments unavailable]" + ) + + def _reset_reply(self) -> None: + self._reply_attempt = None + self._reply_text = "" + if not self.is_running: + return + reply = self.query_one("#reply", Static) + reply.update("") + reply.display = False + + def _update_reply(self, change: ReplyText) -> None: + if change.session_id != self.session_id or change.turn_id != self._reply_turn: + return + if change.attempt_id != self._reply_attempt: + self._reset_reply() + if change.offset != 0: + return + self._reply_attempt = change.attempt_id + if len(self._reply_text) != change.offset: + self._reset_reply() + return + self._reply_text += change.text + reply = self.query_one("#reply", Static) + reply.border_title = "Assistant · responding" + reply.update(self._reply_text + " ▍") + reply.display = True + reply.call_after_refresh(reply.scroll_end, animate=False) + + async def _follow( + self, + initial_cursor: int | None = None, + stopping: asyncio.Event | None = None, + ) -> None: + if self.client is None: + return + if stopping is None: + stopping = asyncio.Event() + self._follower_stopping = stopping + + def reset_attempt(change: ReplyReset) -> None: + if ( + change.session_id == self.session_id + and change.turn_id == self._reply_turn + and change.attempt_id == self._reply_attempt + ): + self._reset_reply() + + def failed() -> None: + if self.is_running: + self.query_one("#connection", Static).update( + "Live updates unavailable. Reopen the client to reconnect." + ) + + await follow_client( + self.client, + FeedPresentation( + selected=lambda: self.session_id, + refresh=self._refresh_sessions, + show=self._show_session, + reset=self._reset_reply, + reply=self._update_reply, + reset_attempt=reset_attempt, + failed=failed, + busy=lambda: self._reply_turn is not None, + stopping=stopping.is_set, + ), + initial_cursor=initial_cursor, + ) + + async def _send(self) -> None: + if self.client is None or self.session_id is None: + return + field = self.query_one("#message", Input) + value = field.value.strip() + if not value: + return + field.value = "" + self.query_one("#transcript", RichLog).write(f"user: {value}") + await self._finish(await self.client.send(self.session_id, value)) + + async def _finish(self, handle: Any) -> None: + selected = self.session_id + self._reply_turn = handle.turn_id + try: + await handle.result() + finally: + self._reply_turn = None + self._reset_reply() + await self._refresh_sessions() + if self.is_running and self.session_id == selected: + await self._show_session() + + async def on_input_submitted(self, event: Input.Submitted) -> None: + if event.input.id == "message": + await self._send() + + async def on_button_pressed(self, event: Button.Pressed) -> None: + if self.client is None or self.session_id is None: + return + if event.button.id == "new-session": + await self.action_new_session() + elif event.button.id == "send": + await self._send() + elif event.button.id in {"approve", "deny"}: + pending = await self.client.pending(self.session_id) + if pending is not None: + handle = await self.client.confirm( + self.session_id, + pending.invocation_id, + Answer(approved=event.button.id == "approve"), + ) + if handle is not None: + await self._finish(handle) + elif event.button.id == "resume": + await self._finish(await self.client.resume(self.session_id)) + + async def on_list_view_selected(self, event: ListView.Selected) -> None: + index = event.list_view.index + if index is not None and index < len(self.sessions): + self.session_id = self.sessions[index].id + await self._show_session() + + +class ClientApp(SessionApp): + """Textual client UI that borrows an embedded or remote client.""" + + def __init__(self, client: ClientProtocol, *, session_id: str | None = None) -> None: + super().__init__(client, session_id=session_id) + + async def on_mount(self) -> None: + await self._connect_client(self._initial_session_id) diff --git a/tests/test_public_interface_boundaries.py b/tests/test_public_interface_boundaries.py new file mode 100644 index 0000000..7334fbb --- /dev/null +++ b/tests/test_public_interface_boundaries.py @@ -0,0 +1,29 @@ +"""Public constructors and client-only terminal import boundaries.""" + +import inspect +import subprocess +import sys + +import pytest + +from tether.client import Client, ClientHost + + +@pytest.mark.parametrize("factory_type", [Client, ClientHost]) +def test_composed_types_have_factory_only_constructors(factory_type): + assert not inspect.signature(factory_type).parameters + with pytest.raises(TypeError, match="ClientHost"): + factory_type() + + +def test_client_tui_import_does_not_load_demo_composition(): + subprocess.run( + [ + sys.executable, + "-c", + "import sys; from tether.tui import ClientApp; " + "assert 'tether.cli.demo' not in sys.modules; " + "assert 'tether.tui._demo' not in sys.modules", + ], + check=True, + )