zettcode 0.1.6__tar.gz → 0.1.7__tar.gz

{zettcode-0.1.6 → zettcode-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: zettcode
-Version: 0.1.6
+Version: 0.1.7
 Summary: A focused terminal coding agent powered by zett-agent
 Project-URL: Repository, https://github.com/Chang-LeHung/zettcode
 Project-URL: Issues, https://github.com/Chang-LeHung/zettcode/issues
@@ -21,13 +21,17 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: exceptiongroup<2,>=1.2; python_version < '3.11'
+Requires-Dist: httpx<1,>=0.27
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: pyperclip<2,>=1.9
 Requires-Dist: setproctitle<2,>=1.3.7; os_name == 'posix'
+Requires-Dist: starlette<2,>=0.48
 Requires-Dist: tiktoken<1,>=0.12
 Requires-Dist: tomli<3,>=2; python_version < '3.11'
 Requires-Dist: truststore<1,>=0.10
+Requires-Dist: uvicorn<1,>=0.35
 Requires-Dist: wcwidth<1,>=0.2
+Requires-Dist: websockets<17,>=15
 Requires-Dist: zett-agent<0.2,>=0.1.15
 Description-Content-Type: text/markdown
 

{zettcode-0.1.6 → zettcode-0.1.7}/pyproject.toml

@@ -29,6 +29,13 @@ dependencies = [
   "pydantic>=2,<3",
   "pyperclip>=1.9,<2",
   "setproctitle>=1.3.7,<2; os_name == 'posix'",
+  # The session broker is an ordinary web server: a Starlette application served by uvicorn. A session reaches it
+  # with httpx (to send) and websockets (to be reachable). The floors are the oldest versions the broker's tests
+  # were run against; all of them arrive through the runtime today and are declared so that is not luck.
+  "starlette>=0.48,<2",
+  "uvicorn>=0.35,<1",
+  "httpx>=0.27,<1",
+  "websockets>=15,<17",
   # The counter behind ``/context`` measures a request with it, and imports it
   # itself: the floor matches the runtime's, so neither resolver has to fight.
   "tiktoken>=0.12,<1",

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/__init__.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
 
 #: The one place the version is written. ``pyproject.toml`` reads it from here
 #: and the release workflow checks the tag against it, so a bump is one edit.
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 
 #: Where each public name lives; read by :func:`__getattr__` on first use.
 _EXPORTS = {

zettcode-0.1.7/src/zettcode/app/agent/agent/base.py

@@ -0,0 +1,54 @@
+"""What every part of the agent shares: the runtime it speaks to, and who and where it is.
+
+The mixins in this package are split by what they are responsible for, and each one
+inherits this class only to be type-checked against what the others rely on. The two
+properties here are read by nearly all of them, which is why they live below all of them.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..runtime import ZettCodeRuntime
+from ..storage import SessionLocked
+
+
+class AgentBase:
+    """The runtime, the workspace it works in, and the session the next turn belongs to."""
+
+    #: The runtime this agent speaks to; the one thing the application agent holds.
+    runtime: ZettCodeRuntime
+
+    @property
+    def workspace(self) -> Path:
+        """Return the workspace displayed in the header."""
+        return self.runtime.config.workspace
+
+    @property
+    def session_id(self) -> str:
+        """Return the session used for the next turn."""
+        return self.runtime.session_id
+
+    @property
+    def session_locked(self) -> bool:
+        """Return whether another process has the active session open, so that this one may only read it.
+
+        Every session is locked by the process that has it open (see :mod:`..storage.locks`). A session this
+        process started is always its own; one it resumed may be somebody else's, and then it is shown and
+        nothing is written to it: no turn, no title, no compaction.
+        """
+        return self.runtime.session_locked
+
+    def retake_session(self) -> bool:
+        """Try again to lock the active session; return whether this process holds it now."""
+        return self.runtime.retake_session()
+
+    def require_session(self) -> None:
+        """Refuse to go on when the active session is another process's.
+
+        Raises:
+            SessionLocked: The lock is not held. A ``ValueError``, which the shell shows as a line in the
+                conversation.
+        """
+        if self.session_locked:
+            raise SessionLocked()

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/agent/context.py

@@ -80,9 +80,11 @@ class ContextMixin(AgentBase):
             worth replacing.
 
         Raises:
+            SessionLocked: Another process has this session open, and a checkpoint is a write.
             ValueError: When the newest checkpoint already covers the branch —
                 a second pass would summarize nothing but the checkpoint.
         """
+        self.require_session()
         if self._compacted_at_the_head():
             raise ValueError("Already compacted; send a message before compacting again")
         await self.runtime.start()

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/agent/prompt.py

@@ -23,6 +23,9 @@ class MentionPart:
     """
 
     token: str
+    #: The words the model reads in the token's place, when it is not to see the token itself. ``None``
+    #: leaves the token as typed; the typed text is what the transcript and the store keep either way.
+    says: str | None = None
 
 
 #: One piece of a user turn, in the order it was written: a run of text, or the
@@ -39,6 +42,29 @@ def plain_text_part(part: PromptPart) -> str:
     return ""
 
 
+def model_text_part(part: PromptPart) -> str:
+    """Return the text one part is to the model: a reference that was resolved reads as what it says."""
+    if isinstance(part, MentionPart) and part.says is not None:
+        return part.says
+    return plain_text_part(part)
+
+
+def mention_parts(parts: Sequence[PromptPart], mentions: MentionRegistry) -> tuple[PromptPart, ...]:
+    """Return a turn with each reference that has words of its own carrying them.
+
+    ``@work`` typed for a session that is running is not a word the model knows, so it is put in the
+    model's reading as ``session "work"`` and :func:`mention_hint` explains it. Anything else — a skill, a
+    file, a name nobody has — keeps the token as it was typed.
+    """
+    if not mentions.providers:
+        return tuple(parts)
+    resolved: list[PromptPart] = []
+    for part in parts:
+        says = mentions.rename_token(part.token) if isinstance(part, MentionPart) else None
+        resolved.append(MentionPart(part.token, says) if says is not None and isinstance(part, MentionPart) else part)
+    return tuple(resolved)
+
+
 def plain_text(parts: Sequence[PromptPart]) -> str:
     """Return a turn as the reader typed it, with its ``@`` tokens back in place."""
     return "".join(plain_text_part(part) for part in parts)

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/agent/sessions.py

@@ -180,7 +180,11 @@ class SessionsMixin(ContextMixin):
         Args:
             title: Name to store; surrounding space is trimmed, and a blank or
                 over-long name is rejected by the store.
+
+        Raises:
+            SessionLocked: Another process has this session open.
         """
+        self.require_session()
         await self.runtime.persistence.set_title(self.session_id, title)
         return title.strip()
 
@@ -199,6 +203,8 @@ class SessionsMixin(ContextMixin):
         """
         if self.runtime.persistence.session_title(session_id) is not None:
             return None
+        if session_id == self.session_id and self.session_locked:
+            return None  # a nicety, and not one that is worth writing into a session that is not ours
         session = self.runtime.persistence.read(session_id)
         branch = session.branch()
         question = next(

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/agent/turns.py

@@ -12,9 +12,10 @@ from zett_agent.extensions.external import ExternalEvent
 from zett_agent.extensions.steering import STEERING_MESSAGE_EVENT_NAME
 from zett_agent.messages import ImageBytesSource, ImageContent, TextContent, UserMessage
 
+from ..dialogue.relay import Relayed
 from ..dialogue.side import SIDE, question
 from .base import AgentBase
-from .prompt import MentionPart, PromptPart, carries_image, plain_text, plain_text_part
+from .prompt import MentionPart, PromptPart, carries_image, model_text_part, plain_text
 
 
 class TurnsMixin(AgentBase):
@@ -30,6 +31,7 @@ class TurnsMixin(AgentBase):
         *,
         hint: str | None = None,
         side: bool = False,
+        relayed: Relayed | None = None,
     ) -> AsyncIterator[AgentEvent]:
         """Run one turn with the selected session, model, and reasoning effort.
 
@@ -43,14 +45,21 @@ class TurnsMixin(AgentBase):
                 what was typed and a restored session shows it.
             side: Ask without letting the exchange join the conversation; see
                 :mod:`zettcode.app.agent.side`.
+            relayed: The turn is a message another session sent. It is what the model reads
+                (with where it came from), and ``parts`` and ``hint`` are not used.
+
+        Raises:
+            SessionLocked: Another process has the session open. Checked before anything else, and a side
+                question is no exception: the store records it even though it never replays it.
         """
+        self.require_session()
         await self.runtime.start()
         client = self.runtime.started
         used = self.runtime.active_model.shown_name
         session_id = self.session_id
         try:
             async for event in client.stream(
-                self.request(parts, hint=hint, side=side),
+                self.request(parts, hint=hint, side=side) if relayed is None else relayed.message(),
                 config=AgentRunConfig(session_id=session_id),
                 model=self.runtime.provider,
                 reasoning_effort=self.runtime.effort,
@@ -105,11 +114,12 @@ class TurnsMixin(AgentBase):
             text = plain_text(parts)
             if hint is None:
                 return text
-            return UserMessage(content=f"{text}\n\n{hint}", attributes={"prompt": text})
+            said = "".join(model_text_part(part) for part in parts)
+            return UserMessage(content=f"{said}\n\n{hint}", attributes={"prompt": text})
         content: list[TextContent | ImageContent] = []
         for part in parts:
             if isinstance(part, (str, MentionPart)):
-                text = plain_text_part(part)
+                text = model_text_part(part)
                 if text:
                     content.append(TextContent(text))
                 continue

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/conversation/entries.py

@@ -38,6 +38,7 @@ class EntryKind(StrEnum):
         THINKING: Reasoning, or a compaction's summary, with its own clock.
         TOOL: One tool call and its bounded result.
         CHANGES: The files a request changed, said once when it ends.
+        RELAY: A message that crossed between two sessions, in either direction.
     """
 
     WELCOME = "welcome"
@@ -50,6 +51,7 @@ class EntryKind(StrEnum):
     THINKING = "thinking"
     TOOL = "tool"
     CHANGES = "changes"
+    RELAY = "relay"
 
 
 class EntryStatus(StrEnum):
@@ -181,6 +183,13 @@ class WaitEntry(TimedEntry):
     kind: EntryKind = field(default=EntryKind.WAIT, init=False)
     title: str = "Processing"
     started_at: float
+    #: The clock reading of the last thing the agent said (a delta, a tool, a step), which is when the model
+    #: was last heard from; ``None`` until it has said anything.
+    heard_at: float | None = None
+    #: Seconds the model has said nothing while nothing else was running, brought up with the timers. Zero
+    #: while a tool, a reasoning row or a compaction is the thing being waited for: a ``pytest`` that takes two
+    #: minutes is not the model going quiet.
+    quiet: float = 0.0
     #: The line the request ended on, written when the row is settled.
     text: str = ""
 
@@ -289,6 +298,24 @@ class DeleteEntry(ToolEntry):
     path: str = ""
 
 
+@dataclass(slots=True, kw_only=True)
+class MessageEntry(ToolEntry):
+    """A message the agent sent to another session: who it was for, and every word of it.
+
+    The tool's own answer is one line (``Delivered to work …``); what the reader wants to see is what
+    was said, which the call's arguments hold and a one-line title cannot, so the entry keeps it and the
+    row shows it — a few lines folded, the whole message expanded.
+    """
+
+    to: str = ""
+    message: str = ""
+
+    @property
+    def foldable(self) -> bool:
+        """Return whether there is more to see once the call is over: what was said, or how it ended."""
+        return not self.running and bool(self.message or self.text)
+
+
 @dataclass(frozen=True, slots=True)
 class FileSummary:
     """What one request did to one file, in total.
@@ -316,3 +343,26 @@ class ChangesEntry(Entry):
 
     kind: EntryKind = field(default=EntryKind.CHANGES, init=False)
     files: tuple[FileSummary, ...] = ()
+
+
+@dataclass(slots=True, kw_only=True)
+class RelayEntry(Entry):
+    """A message between two sessions: one this session received, or one its reader sent.
+
+    Attributes:
+        peer: The other session's handle.
+        text: The message.
+        outgoing: This session sent it; otherwise it arrived.
+        by_agent: The other session's agent wrote it (received), or this session's reader chose to
+            send it with ``@`` (sent, so ``False``).
+        external: It came from a program that is not a ZettCode session, whose name nobody has checked.
+        note: What became of a sent message, such as ``queued``; empty for a received one.
+    """
+
+    kind: EntryKind = field(default=EntryKind.RELAY, init=False)
+    peer: str
+    text: str
+    outgoing: bool = False
+    by_agent: bool = True
+    external: bool = False
+    note: str = ""

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/conversation/presenters.py

@@ -37,7 +37,17 @@ from ....tui import (
     TextLine,
     Theme,
 )
-from ....tui.render import SweepSpan, display_width, highlight, inset_line, layout_rich_lines, sweep_spans, truncate
+from ....tui.render import (
+    SweepSpan,
+    blend,
+    display_width,
+    highlight,
+    inset_line,
+    layout_rich_lines,
+    sweep_spans,
+    truncate,
+    wrap_words,
+)
 from ....tui.widgets.markdown import MarkdownSource
 from ...brand import LOGO_LINES
 from .entries import (
@@ -49,8 +59,10 @@ from .entries import (
     FileChangeEntry,
     FileSummary,
     MarkdownEntry,
+    MessageEntry,
     NoticeLevel,
     ReadEntry,
+    RelayEntry,
     TextEntry,
     ThinkingEntry,
     ToolEntry,
@@ -69,6 +81,7 @@ from .rows import (
     duration_text,
     elapsed_text,
     moving,
+    quiet_text,
     sweep_column,
     terminal_safe,
 )
@@ -97,6 +110,8 @@ TOOL_ROLES = {
     "todo_write": "plan",
     "read_skill": "read",
     "task": "subagent",
+    "send_message": "message",
+    "list_sessions": "message",
 }
 
 
@@ -184,11 +199,27 @@ class Presenter(Generic[E], ABC):
         return entry.block
 
     @staticmethod
-    def text_lines(text: str, width: int, style: Style, *, indent: int = 0) -> list[TextLine]:
-        """Wrap text with the same layout used by RichText and Markdown."""
-        source = tuple(TextLine((Span(line, style),)) for line in text.split("\n"))
+    def text_lines(text: str, width: int, style: Style, *, indent: int = 0, words: bool = False) -> list[TextLine]:
+        """Wrap text with the same layout used by RichText and Markdown.
+
+        Args:
+            text: What to wrap; each newline starts a new row.
+            width: Columns available.
+            style: The ink the text is drawn in.
+            indent: Columns left empty at the start of every row.
+            words: Break between words and not mid-word. For a sentence a reader is meant to read, such as an
+                error naming a command to try; left off, a row breaks at the column, as code and output must.
+        """
         margin = min(indent, max(0, width - 1))
-        return [inset_line(row, margin) for row in layout_rich_lines(source, max(1, width - margin))]
+        room = max(1, width - margin)
+        if words:
+            rows = [piece for line in text.split("\n") for piece in wrap_words(line, room)]
+            # A character wider than the whole row (a wide glyph in a column or two) cannot be placed in it;
+            # the layout that wraps by column cuts such a row to the budget, and so does this.
+            fitted = layout_rich_lines(tuple(TextLine((Span(row, style),)) for row in rows), room, wrap=False)
+            return [inset_line(row, margin) for row in fitted]
+        source = tuple(TextLine((Span(line, style),)) for line in text.split("\n"))
+        return [inset_line(row, margin) for row in layout_rich_lines(source, room)]
 
 
 class WelcomePresenter(Presenter[TextEntry]):
@@ -236,7 +267,7 @@ class NoticePresenter(Presenter[TextEntry]):
     def lines(self, entry: TextEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
         """Leave a blank separator and let the transcript gutter add the inset."""
         colour = theme.error if entry.level == NoticeLevel.ERROR else theme.muted
-        return [TextLine(), *self.text_lines(entry.text, width, Style(foreground=colour))]
+        return [TextLine(), *self.text_lines(entry.text, width, Style(foreground=colour), words=True)]
 
 
 class AnnouncementPresenter(Presenter[TextEntry]):
@@ -309,6 +340,79 @@ class UserPresenter(Presenter[TextEntry]):
         return lines
 
 
+def relay_detail(theme: Theme) -> str:
+    """Return the colour of the quiet words on a message between sessions (``delivered``, ``queued``).
+
+    The surface is a little lighter than the reader's own, and the usual quiet text would be too close to
+    it, so the words are taken halfway to the body colour: still quieter than the message, and readable.
+    """
+    return blend(theme.subtle, theme.text, 0.5)
+
+
+class RelayPresenter(Presenter[RelayEntry]):
+    """Draw a message between two sessions the way the reader's own message is drawn, on a surface of its own.
+
+    Same arrow, same text column, same filled rows as what the reader types — it is part of the
+    conversation — but on a different background, with a line above the text that says whose it is::
+
+        ← agent of session fix-the-parser
+        › The tokenizer change is merged; can you rerun the parser tests?
+
+        → to session fix-the-parser · queued
+        › yes, on it
+
+    The header is the one place colour says who spoke: the message colour (mauve) for another session's
+    *agent* (another agent, as a delegated child is), the warning yellow for another session's reader,
+    and the accent for this reader's own message to it.
+    """
+
+    kind = EntryKind.RELAY
+    gutter = True
+
+    def lines(self, entry: RelayEntry, width: int, theme: Theme, frame: int) -> list[TextLine]:
+        """Return the header and the wrapped message on the surface, every row filled to the edge."""
+        if entry.outgoing:
+            tone = theme.accent
+        elif entry.external:
+            tone = theme.warning
+        elif entry.by_agent:
+            tone = theme.tools.message
+        else:
+            tone = theme.warning
+        style = Style(foreground=theme.text, background=theme.surface_peer)
+        margin = min(CONTENT_INDENT, max(0, width - 1))
+        pad = " " * display_width(PROMPT)
+        peer = terminal_safe(entry.peer).replace("\n", " ")
+        if entry.outgoing:
+            label = f"\u2192 to session {peer}"
+            detail = f" {SEPARATOR} {entry.note}" if entry.note else ""
+        else:
+            label = (
+                f"\u2190 external source {peer}"
+                if entry.external
+                else f"\u2190 {'agent' if entry.by_agent else 'user'} of session {peer}"
+            )
+            detail = ""
+
+        def row(*spans: Span) -> TextLine:
+            used = sum(display_width(span.text) for span in spans)
+            return TextLine((*spans, Span(" " * max(0, width - used), style)))
+
+        head = truncate(f"{pad} {label}", width)
+        tail = truncate(detail, max(0, width - display_width(head)))
+        header = row(
+            Span(head, Style(foreground=tone, background=theme.surface_peer)),
+            Span(tail, Style(foreground=relay_detail(theme), background=theme.surface_peer)),
+        )
+        blank = row()
+        lines = [TextLine(), blank, header]
+        for index, text in enumerate(self.text_lines(terminal_safe(entry.text), max(1, width - margin), style)):
+            prefix = f"{PROMPT} " if index == 0 else f"{pad} "
+            lines.append(row(Span(truncate(f"{prefix}{text.text}", width), style)))
+        lines.append(blank)
+        return lines
+
+
 class WaitPresenter(Presenter[WaitEntry]):
     """Draw the pinned wait row: a sweep while it runs, a line once it has ended.
 
@@ -349,8 +453,16 @@ class WaitPresenter(Presenter[WaitEntry]):
             ]
         spans = list(_running_label(entry.title, theme, frame))
         if entry.duration is not None:
-            aside = f" ({elapsed_text(entry.duration)} {SEPARATOR} {STOP_HINT})"
-            spans.append(Span(aside, Style(foreground=theme.muted)))
+            quiet = quiet_text(entry.quiet)
+            said = f"{elapsed_text(entry.duration)} {SEPARATOR} "
+            if quiet is not None:
+                # In the warning ink, apart from the quiet aside around it: this is the one thing in the row
+                # that says something may be wrong, and a reader who has been waiting is looking for it.
+                spans.append(Span(f" ({said}", Style(foreground=theme.muted)))
+                spans.append(Span(quiet, Style(foreground=theme.warning)))
+                spans.append(Span(f" {SEPARATOR} {STOP_HINT})", Style(foreground=theme.muted)))
+            else:
+                spans.append(Span(f" ({said}{STOP_HINT})", Style(foreground=theme.muted)))
         return [TextLine(), layout_rich_lines((TextLine(tuple(spans)),), width, wrap=False)[0]]
 
 
@@ -465,6 +577,44 @@ class ToolPresenter(Presenter[T]):
         return lines
 
 
+class SessionMessagePresenter(ToolPresenter[MessageEntry]):
+    """A message the agent sent to another session: what it said, then how it ended.
+
+    Folded, the row shows the first lines of the message and the one-line outcome; expanded, every
+    line of the message. The message comes first because it is the substance of the call; the outcome
+    (``Delivered to work …``, or why it was not) is a line of its own underneath, in the colour of the
+    result — muted when it went, the error colour when it did not.
+    """
+
+    entry_type = MessageEntry
+
+    def body_lines(self, entry: MessageEntry, width: int, theme: Theme, muted: Style) -> list[TextLine]:
+        """Return the message, bounded as any tool output is, and the outcome under it."""
+        if entry.running:
+            return []
+        inner = max(1, width - CONTENT_INDENT * 2)
+        limit = TOOL_EXPANDED_ROWS if entry.expanded else TOOL_PREVIEW_ROWS
+        detail = Style(foreground=theme.subtle)
+        gutter = Style(foreground=theme.muted)
+        lines: list[TextLine] = []
+        rows, omitted = bounded_rows(entry.message, inner, limit) if entry.message else ([], 0)
+        for index, row in enumerate(rows):
+            lead = f"{' ' * CONTENT_INDENT}\u2514 " if index == 0 else " " * (CONTENT_INDENT * 2)
+            lines.append(TextLine((Span(lead, gutter), Span(row, detail))))
+        if omitted:
+            lines.append(TextLine((Span(f"{' ' * (CONTENT_INDENT * 2)}{ELLIPSIS} {omitted} more rows", muted),)))
+        if entry.text:
+            ended = Style(foreground=theme.error if entry.status is EntryStatus.FAILED else theme.muted)
+            # An arrow, so the answer is not read as the last line of the message above it.
+            outcome, more = bounded_rows(entry.text, max(1, inner - 2), 3 if entry.expanded else 1)
+            for index, row in enumerate(outcome):
+                lead = f"{' ' * CONTENT_INDENT}\u2192 " if index == 0 else " " * (CONTENT_INDENT * 2)
+                lines.append(TextLine((Span(f"{lead}{row}", ended),)))
+            if more and not entry.expanded:
+                lines[-1] = TextLine((Span(f"{lines[-1].text} {ELLIPSIS}", ended),))
+        return lines
+
+
 class ReadPresenter(ToolPresenter[ReadEntry]):
     """A file that was read: the body is highlighted as the language the file is in."""
 
@@ -704,9 +854,11 @@ DEFAULT_PRESENTERS = Presenters(
         ThinkingPresenter(),
         ToolPresenter(),
         ChangesPresenter(),
+        RelayPresenter(),
         ReadPresenter(),
         WritePresenter(),
         EditPresenter(),
+        SessionMessagePresenter(),
     )
 )
 

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/conversation/projection.py

@@ -11,6 +11,7 @@ from zett_agent.extensions.shell_approval import SHELL_APPROVAL_EVENT_NAME
 from zett_agent.messages import ToolMessage
 
 from ..dialogue.ask import AskUserQuestion, question_from
+from ..dialogue.relay import Relayed
 from ..extensions.mcp_notice import MCP_NOTICE_EVENT_NAME, notice_from
 from ..extensions.usage import USAGE_EVENT_NAME
 from .entries import EntryStatus
@@ -81,14 +82,27 @@ class TranscriptProjector(AgentEventDispatcher):
         self.on_steering_started = on_steering_started
         self.on_steering_interrupted = on_steering_interrupted
 
-    def begin_turn(self, prompt: str, *, side: bool = False) -> None:
+    def begin_turn(self, prompt: str, *, side: bool = False, relayed: Relayed | None = None) -> None:
         """Echo the prompt into the transcript before the run starts.
 
         Args:
             prompt: What the reader asked.
             side: The question is a side one, which the transcript shows as such.
+            relayed: The turn answers a message another session sent, which the transcript shows as that.
         """
-        self.transcript.begin_turn(prompt, side=side)
+        if relayed is None:
+            self.transcript.begin_turn(prompt, side=side)
+        else:
+            self.transcript.begin_turn(prompt, side=side, relayed=relayed)
+
+    async def dispatch(self, event: AgentEvent) -> None:
+        """Note that the agent spoke, then hand the event to the callback that draws it.
+
+        Every event ends a silence, whichever it is: the waiting row counts how long it has been since the model
+        last said anything, and has to be told each time it does.
+        """
+        self.transcript.heard()
+        await super().dispatch(event)
 
     async def on_compaction_started_event(self, event: AgentEvent) -> None:
         """Open the compaction row; the summary streams into it as it arrives."""

{zettcode-0.1.6 → zettcode-0.1.7}/src/zettcode/app/agent/conversation/rendering.py

@@ -32,7 +32,8 @@ from pathlib import Path
 
 from ....tui import ELLIPSIS, SEPARATOR
 from ....tui.render import GENERIC, language_for
-from .entries import DeleteEntry, EditEntry, ReadEntry, ToolEntry, WriteEntry
+from .entries import DeleteEntry, EditEntry, MessageEntry, ReadEntry, ToolEntry, WriteEntry
+from .rows import limit_output
 
 #: Output kinds the chain shapes; a link claims one or more of them.
 TOOL = "tool"
@@ -539,6 +540,39 @@ class TaskTool(ToolHandler):
         return output
 
 
+_UUID = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
+
+
+class MessageTool(ToolHandler):
+    """``send_message``: a message to another session, kept whole so the row can show it."""
+
+    names = frozenset({"send_message"})
+
+    def describe(self, name: str, arguments: Mapping[str, object]) -> ToolRow:
+        """Say who it is for; an id is shortened to its end, which is how a session is named without a title."""
+        return ToolRow(f"Message to {self._recipient(argument(arguments, 'to', '(unknown)'))}")
+
+    @staticmethod
+    def _recipient(to: str) -> str:
+        """Return the recipient as a reader can use it: a name as it is, an id by its last characters."""
+        return f"session {to[-6:]}" if _UUID.fullmatch(to) else to
+
+    def open_tool(
+        self, name: str, arguments: Mapping[str, object], *, id: int, call_id: str, started_at: float
+    ) -> ToolEntry:
+        """A message row, which holds the text that was sent."""
+        message = arguments.get("message")
+        return MessageEntry(
+            id=id,
+            call_id=call_id,
+            tool=name,
+            title=self.describe(name, arguments).title,
+            to=argument(arguments, "to"),
+            message=limit_output(message) if isinstance(message, str) else "",
+            started_at=started_at,
+        )
+
+
 class FallbackTool(ToolHandler):
     """Anything no other link claims: its name and flat arguments, never JSON."""
 
@@ -610,6 +644,7 @@ DEFAULT_RENDERERS = Renderers(
         TodoTool(),
         SkillTool(),
         TaskTool(),
+        MessageTool(),
         FallbackTool(),
         ReasoningHandler(),
         AnswerHandler(),