zettcode-sdk 0.3.4__py3-none-any.whl

zettcode/sdk/extensions/mcp.py

@@ -0,0 +1,276 @@
+"""The MCP extension ZettCode hands to the runtime: one broken server never stops the task.
+
+zett-agent's :class:`McpExtension` connects the servers a configuration file names and registers
+their tools. Two things used to make it brittle, and this module is about not letting either one
+end a conversation:
+
+* A server that would not start failed the whole request (zett-agent 0.1.14), and the failure
+  named nothing. Since 0.1.15 the framework skips a server that cannot be reached or listed,
+  carries on with the others, and tells *the model*. This adds the other half: it tells *the
+  reader*, once, through the transcript, because a tool that quietly is not there looks like a
+  bug in the program.
+* One malformed entry in ``mcp.json`` invalidated the file, and a file that is not valid JSON
+  failed the construction of the extension — which happens while the runtime is being built, so
+  the first turn never ran. Entries that cannot be used are skipped and named, and a file that
+  cannot be read at all means "no MCP servers" plus a line saying why.
+
+* Starting a server is slow and silent. A stdio server is a process — ``npx`` may download a package
+  first — and the framework connects and lists its tools while the first request waits, so the
+  reader saw "Processing" for as long as that took with nothing to say why. A line is said when each
+  server starts and when it is ready, with how long it took and how many tools it brought. A server
+  whose tool list is already cached starts nothing, so it says nothing.
+
+  That is said **once per session, at its first turn**: it explains why that turn was slow, and only
+  that turn. The framework forgets a tool list after five minutes and lists it again at the top of the
+  next request, which in a long conversation is most turns; a reader does not need to be told again
+  each time that servers they already know about were looked at. A subagent, which has a session of its
+  own beside the one the reader is in, says nothing: the reader never asked it anything.
+
+A tool that fails while it runs is the framework's own business and already harmless: the failure
+comes back to the model as an ordinary failed tool result, and the model carries on.
+
+What this does *not* do is catch everything. A cancellation is how the reader stops a request, and
+turning it into some other error would make Escape fail instead of stop; only ``Exception`` is
+absorbed here.
+
+The module is imported when a runtime starts, not when the application is imported: the MCP SDK it
+builds on costs more than the first frame.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from contextvars import ContextVar
+from pathlib import Path
+from typing import Any, cast
+
+from zett_agent.agent import AgentRunContext
+from zett_agent.events import AgentEvent, AgentEventType
+from zett_agent.extensions.mcp import DEFAULT_MCP_SERVER_KEYS, McpConfiguration, McpExtension, McpStdioServer
+
+from zettcode.engine.extensions.mcp_notice import MCP_NOTICE_EVENT_NAME, notice_payload
+from zettcode.error_text import describe_error
+
+#: The request whose tools are being discovered, so a server starting on its own task can say so in
+#: that request's transcript. Set around the framework's discovery and read by the tasks it spawns, which
+#: inherit it; ``None`` outside one.
+_DISCOVERING: ContextVar[AgentRunContext | None] = ContextVar("zettcode_mcp_discovering", default=None)
+
+
+class ReportingMcpExtension(McpExtension):
+    """An MCP extension that keeps going when a server or a config entry is broken, and says so.
+
+    Args:
+        **options: Passed to :class:`McpExtension`. ``strict_config`` defaults to ``False`` here:
+            the framework's default makes one bad entry invalidate every other server.
+    """
+
+    def __init__(self, **options: Any) -> None:
+        options.setdefault("strict_config", False)
+        super().__init__(**options)
+        #: What each unavailable server was last reported as, so a server that stays down is
+        #: reported once rather than at the top of every turn.
+        self._reported: dict[str, str] = {}
+        #: The stamp of the configuration file that was last checked for entries to report.
+        self._checked: tuple[int, int] | None | object = _UNCHECKED
+        #: Lines to say at the first request: what went wrong before there was a request to say it in.
+        self.startup_issues: list[str] = []
+        #: The sessions whose first turn has been and gone, which is when the start of the servers is said.
+        self._narrated: set[str] = set()
+
+    async def on_tool(self, context: AgentRunContext) -> None:
+        """Register the tools of every server that works, and tell the reader about the ones that do not.
+
+        An error the framework does not handle itself — it handles a server that cannot connect or
+        list — costs this request its MCP tools and nothing else.
+        """
+        token = _DISCOVERING.set(context)
+        try:
+            await super().on_tool(context)
+        except Exception as error:
+            # Not BaseException: a cancellation has to stay a cancellation. The framework has
+            # already closed what it opened for this request before the error got here.
+            await self._say(context, f"MCP is unavailable for this request: {describe_error(error)}")
+            return
+        finally:
+            _DISCOVERING.reset(token)
+            # After the discovery, not before: every server of this turn is narrated or none is.
+            if self._is_a_reader_session(context):
+                self._narrated.add(cast(str, context.config.session_id))
+        for line in (*self.startup_issues, *self._config_issues(), *self._server_issues(context)):
+            await self._say(context, line)
+        self.startup_issues.clear()
+
+    async def _discover(self, request: Any, server: Any) -> Any:
+        """Connect to one server and list its tools, saying when it starts and when it is ready.
+
+        The framework's cache decides whether anything is started at all; when it holds this
+        server's tools nothing is, and nothing is said. The server's command and arguments are
+        never repeated here — they can carry a key — only its name and what kind of server it is.
+        """
+        context = _DISCOVERING.get()
+        cached = self._tool_cache.get(server.name)
+        starts = (
+            context is not None
+            and self._first_turn_of_a_reader_session(context)
+            and not (cached is not None and cached.server == server and cached.expires_at > time.monotonic())
+        )
+        began = time.monotonic()
+        if starts:
+            kind = "process" if isinstance(server, McpStdioServer) else "connection"
+            await self._say_quietly(context, f"Starting MCP server {server.name!r} ({kind})\u2026")
+        tools = await super()._discover(request, server)
+        if starts and tools is not None:
+            count = len(tools)
+            took = time.monotonic() - began
+            noun = "tool" if count == 1 else "tools"
+            await self._say_quietly(context, f"MCP server {server.name!r} is ready: {count} {noun}, {took:.1f}s")
+        return tools
+
+    @staticmethod
+    def _is_a_reader_session(context: AgentRunContext) -> bool:
+        """Return whether this request belongs to a session the reader is in, not to a subagent's own."""
+        return not context.config.parent_session_id
+
+    def _first_turn_of_a_reader_session(self, context: AgentRunContext) -> bool:
+        """Return whether this is the first request its session has made, in a session the reader is in."""
+        return self._is_a_reader_session(context) and cast(str, context.config.session_id) not in self._narrated
+
+    async def _say_quietly(self, context: AgentRunContext | None, text: str, level: str = "info") -> None:
+        """Say a line without letting the saying fail the discovery it reports on.
+
+        These are progress lines (a server is starting, or ready), so they are ``info`` unless said otherwise.
+        """
+        if context is None:
+            return
+        try:
+            await self._say(context, text, level)
+        except Exception:  # noqa: BLE001 - news about a server must never be what stops it
+            pass
+
+    def _server_issues(self, context: AgentRunContext) -> list[str]:
+        """Return a line for each server that became unavailable, or changed why, since last said.
+
+        The framework keeps the reason on the request it made for this context and tells the model
+        through the system prompt; neither is a way to ask it, so this reads the request. A server
+        that works again is forgotten, so that its next failure is news.
+        """
+        request = self._requests.get(context)
+        unavailable: dict[str, str] = dict(getattr(request, "unavailable", {}) or {})
+        for name in [name for name in self._reported if name not in unavailable]:
+            del self._reported[name]
+        lines = []
+        for name, reason in unavailable.items():
+            if self._reported.get(name) != reason:
+                self._reported[name] = reason
+                lines.append(f"MCP server {name!r} is not available ({reason}); its tools are skipped until it works")
+        return lines
+
+    def _config_issues(self) -> list[str]:
+        """Return a line for each entry of the configuration file that cannot be used.
+
+        Checked when the file is first seen and again whenever it changes, not on every turn.
+        """
+        path = self.config_path
+        if path is None:
+            return []
+        try:
+            status = path.stat()
+        except OSError:
+            self._checked = None
+            return []
+        stamp = (status.st_mtime_ns, status.st_size)
+        if stamp == self._checked:
+            return []
+        self._checked = stamp
+        try:
+            skipped = McpConfiguration.from_file(path, server_keys=self.server_keys, strict=False).skipped
+        except (OSError, ValueError) as error:
+            return [f"{path.name} cannot be used, so the last working MCP servers stay: {describe_error(error)}"]
+        return [f"MCP server {name!r} in {path.name} is ignored: {reason}" for name, reason in skipped.items()]
+
+    @staticmethod
+    async def _say(context: AgentRunContext, text: str, level: str = "warn") -> None:
+        """Publish one line for the transcript.
+
+        A line is a warning unless it says otherwise: what reaches here from the checks (a server that is down, an
+        entry that is ignored, a file that cannot be read) is something the reader may need to act on, and only the
+        progress lines of a start say ``info``.
+        """
+        await context.emit(
+            AgentEvent(
+                type=AgentEventType.CUSTOM,
+                session_id=cast(str, context.config.session_id),
+                name=MCP_NOTICE_EVENT_NAME,
+                payload=notice_payload(text, level),
+            )
+        )
+
+
+#: Marks a stamp that has not been read yet, as distinct from a file that does not exist.
+_UNCHECKED = object()
+
+
+def build_mcp_extension(path: str | Path) -> ReportingMcpExtension:
+    """Return the MCP extension for a server file, whatever state the file is in.
+
+    The framework reads the file while the extension is constructed and raises when it is not
+    valid JSON or names no servers. This runs while the runtime is being built, so letting that
+    through would mean the first turn never starts because of a typo in a file the reader may not
+    even remember. The extension is built with no servers instead, and the reason is said at the
+    first request. Fixing the file takes effect on the next start: an extension that never loaded
+    a good file has nothing to reload.
+
+    Args:
+        path: The server file the reader configured.
+    """
+    try:
+        return ReportingMcpExtension(config_path=path)
+    except (OSError, ValueError) as error:
+        extension = ReportingMcpExtension(servers=())
+        name = Path(path).name
+        extension.startup_issues.append(
+            f"{name} cannot be read, so MCP is off: {describe_error(error)}. Fix it and restart."
+        )
+        return extension
+
+
+def build_scoped_mcp_extension(paths: Sequence[Path]) -> ReportingMcpExtension | None:
+    """Return the MCP extension for the server files that exist, the first file winning a server name.
+
+    One file is :func:`build_mcp_extension`, which also notices the file changing. Several are read
+    once, here, and merged: the framework watches one path, and a server list assembled from two
+    files has no single file to watch. A file that cannot be read costs only its own servers, and
+    says why at the first request; an entry in it that cannot be used is named the same way.
+
+    Args:
+        paths: The files to read, the one that wins a name first; a path that is not a file is skipped.
+
+    Returns:
+        The extension, or ``None`` when no path is a file, so a run with nothing configured carries no
+        MCP instructions at all.
+    """
+    present = [path for path in paths if path.is_file()]
+    if not present:
+        return None
+    if len(present) == 1:
+        return build_mcp_extension(present[0])
+    servers: dict[str, Any] = {}
+    issues: list[str] = []
+    for path in present:
+        label = f"{path.parent.name}/{path.name}"
+        try:
+            loaded = McpConfiguration.from_file(path, server_keys=DEFAULT_MCP_SERVER_KEYS, strict=False)
+        except (OSError, ValueError) as error:
+            issues.append(
+                f"{label} cannot be read, so its servers are off: {describe_error(error)}. Fix it and restart."
+            )
+            continue
+        issues.extend(f"MCP server {name!r} in {label} is ignored: {reason}" for name, reason in loaded.skipped.items())
+        for server in loaded.servers:
+            # The earlier file wins, so a project's server of the same name replaces the user's.
+            servers.setdefault(server.name, server)
+    extension = ReportingMcpExtension(servers=tuple(servers.values()))
+    extension.startup_issues.extend(issues)
+    return extension

zettcode/sdk/extensions/messaging.py

@@ -0,0 +1,281 @@
+"""The tools that let the model talk to the other ZettCode sessions running on this machine.
+
+``list_sessions`` says who is there, and which group chats this session may write to; ``send_message`` hands one of
+them a message, or every member of a group; ``message_history`` reads what this session and another one (or a group)
+said to each other before, from the broker's persistent store; ``manage_group`` makes and changes group chats. The other session
+receives it as a turn of its own — drawn there as a message from this session, with this session's
+id so that it can answer — and this call returns as soon as it has taken the message, not when it has
+finished with it. A message asks for one of two things while that session is busy: it can be handed to
+the request it is running (``mode="steer"``, the default) or wait until that request ends
+(``mode="followup"``); an idle session starts a turn either way. What it does about the message is its
+own agent's business, and its answer, if any, arrives here as a message of its own.
+
+All are request-scoped like every tool: they are registered for each request, and a request that is a side
+question keeps only ``list_sessions`` and ``message_history`` (see :mod:`zettcode.engine.dialogue.side`), because
+sending a message is not reading.
+"""
+
+from __future__ import annotations
+
+import time
+
+from zett_agent.agent import AgentRunContext
+from zett_agent.extensions.base import AgentExtension
+from zett_agent.tools.base import AgentTool, tool
+
+from zettcode.broker.client import SendError
+from zettcode.broker.protocol import VIA_AGENT
+from zettcode.modes import MODE_STEER, MODES
+
+from ..messenger import Messenger
+
+LIST_SESSIONS_TOOL_NAME = "list_sessions"
+SEND_MESSAGE_TOOL_NAME = "send_message"
+MESSAGE_HISTORY_TOOL_NAME = "message_history"
+MANAGE_GROUP_TOOL_NAME = "manage_group"
+
+#: The most characters of one stored message ``message_history`` shows; a longer one is cut, with its length.
+HISTORY_TEXT = 600
+
+#: What a refused send says, by the reason the broker gave, for the ones a model can do something about.
+_ADVICE = {
+    "unknown": "No such session is active. Call list_sessions to see who is.",
+    "ambiguous": "More than one session matches. Use the session id from list_sessions.",
+    "self": "That is this session; a message to yourself is not sent.",
+    "loop": "This conversation between sessions has gone on long enough; stop replying and tell your user.",
+    "rate": "Too many messages were sent in a short time. Wait before sending another.",
+    "offline": "The session broker is not running, so no other session can be reached right now.",
+    "denied": "You are not a member of that group. list_sessions shows the groups you may write to.",
+    "gone": "Nobody there is connected right now.",
+    "internal": "The broker failed while delivering that. Try again; if it keeps failing, tell your user.",
+}
+
+
+def _sentence(error: SendError) -> str:
+    """Return what the model is told when a message did not arrive."""
+    advice = _ADVICE.get(error.reason)
+    if advice is None:
+        return str(error)
+    # Offline has nothing to add to what the advice says; the others carry the broker's own detail.
+    return advice if error.reason == "offline" else f"{str(error).rstrip('.')}. {advice}"
+
+
+class SessionMessagingExtension(AgentExtension):
+    """Register ``list_sessions`` and ``send_message`` for a messenger."""
+
+    def __init__(self, messenger: Messenger) -> None:
+        """Keep the messenger the tools talk through."""
+        self.messenger = messenger
+
+    async def on_tool(self, context: AgentRunContext) -> None:
+        """Register both tools for this request."""
+        context.register_tool(self._list_tool())
+        context.register_tool(self._send_tool())
+        context.register_tool(self._history_tool())
+        context.register_tool(self._group_tool())
+
+    def _list_tool(self) -> AgentTool:
+        """Create the tool that lists the other active sessions."""
+        messenger = self.messenger
+
+        @tool(name=LIST_SESSIONS_TOOL_NAME)
+        async def list_sessions() -> str:
+            """List the other ZettCode sessions that are running on this machine right now, and the group chats
+            this session is a member of (the only ones it may write to).
+            Each session line gives the name to address it by, its id, what it is about, whether it is idle or working,
+            and the directory it works in; each group line gives #name and its members. Sessions come and go, so the
+            list is only true now.
+
+            Snippet:
+                list_sessions()
+
+            Guidelines:
+                - Call this before send_message when you do not already know the id of the session to message.
+                - A session that is working still receives a message; it handles it when its current request ends.
+                - Other sessions belong to the same user, but each one has its own conversation and its own files in mind.
+            """
+            others = messenger.peers()
+            groups = messenger.groups()
+            if not others and not groups:
+                if messenger.connected:
+                    return "No other ZettCode session is running."
+                return "No other session can be seen: the session broker is not running."
+            lines = []
+            if others:
+                lines.append(f"{len(others)} other session{'s' if len(others) != 1 else ''}:")
+            else:
+                lines.append("No other ZettCode session is running.")
+            for entry in others:
+                about = f'"{entry.title}"' if entry.title else "untitled"
+                lines.append(f"- {entry.handle} (id {entry.session_id}) {about}, {entry.status}, in {entry.workspace}")
+            if groups:
+                names = {entry.session_id: entry.handle for entry in messenger.client.roster}
+                lines.append(f"{len(groups)} group chat{'s' if len(groups) != 1 else ''} you may write to:")
+                for group in groups:
+                    members = ", ".join(names.get(m, f"{m[:8]} (offline)") for m in group.members)
+                    lines.append(f"- #{group.name}: {members}")
+            return "\n".join(lines)
+
+        return list_sessions
+
+    def _send_tool(self) -> AgentTool:
+        """Create the tool that sends a message to another active session."""
+        messenger = self.messenger
+
+        @tool(name=SEND_MESSAGE_TOOL_NAME)
+        async def send_message(to: str = "", message: str = "", mode: str = MODE_STEER, group: str = "") -> str:
+            """Send a message to another running ZettCode session, or to every other member of a group chat you are
+            in. The receiver gets it as a request of its own. Returns once they have taken the message, not once
+            they have acted on it: a reply, if one is sent, arrives later as a message to you. Every message costs its
+            receiver a turn, so send one only when it changes what they will do.
+
+            Args:
+                message: What to tell them. They cannot see this conversation, so say everything they need: what you
+                    want, which files or facts matter, and what a useful answer looks like.
+                to: The session to message: its id from list_sessions, or the name listed beside it. Give this or group.
+                group: A group chat to write to instead, such as "review" (as listed by list_sessions, without the
+                    #). Every other member that is connected receives the message, and everyone can read it.
+                mode: What a busy receiver should do. "steer" (the default) hands the message to the request it is
+                    running, so it changes course now; "followup" waits until that request ends. A session that is
+                    idle starts on the message either way.
+
+            Snippet:
+                send_message(to="fix-parser", message="The tokenizer change is merged; please rerun your tests.")
+                send_message(to="fix-parser", message="Also check the tab case.", mode="followup")
+                send_message(group="review", message="Round one is done; findings are in docs/review.md.")
+
+            Guidelines:
+                - Send a message only when your user asked you to, or when the work needs something only another session can do.
+                - The receiver cannot see this conversation, so write a message that stands on its own.
+                - Do not send the same message twice; a message that was taken is being handled.
+                - Reply only when the message needs an answer: it asks a question, asks you to do something, or you have a result, a blocker or a decision the sender is waiting for. Otherwise stay silent.
+                - Never send thanks, "got it", "ok", "done", "bye" or any other closing courtesy, and do not answer one you receive: a conversation ends when nobody needs anything more, and replying to a goodbye starts a loop that costs tokens for both sides.
+                - When the work is finished, send one message with the result if someone is waiting for it, then stop. Do not confirm that you sent it.
+                - Write to a group only when all of its members need to know; otherwise message one session. In a group, do not reply just because you were addressed: answer only when you are the one who has what was asked for, and never echo agreement that others have already given.
+                - Your answer to your own user is not sent to the other session; only this tool sends anything.
+            """
+            if mode not in MODES:
+                raise ValueError("mode is 'steer' or 'followup'")
+            if not message.strip():
+                raise ValueError("a message needs some text")
+            if bool(to) == bool(group):
+                raise ValueError("give exactly one of 'to' (a session) or 'group' (a group chat)")
+            try:
+                if group:
+                    sent = await messenger.send_group(group, message, via=VIA_AGENT, mode=mode)
+                    names = ", ".join(peer.handle for peer, _ in sent.delivered)
+                    note = f"; not delivered to {', '.join(h for h, _ in sent.failed)}" if sent.failed else ""
+                    return f"Delivered to #{sent.group}: {names}{note}."
+                delivered = await messenger.send(to, message, via=VIA_AGENT, mode=mode)
+            except SendError as error:
+                raise ValueError(_sentence(error)) from error
+            peer = delivered.to
+            said = {
+                "started": "started on it now",
+                "steered": "steered it into the request it was running",
+                "queued": "queued it until its current request ends",
+                "delivered": "delivered it to that session's chat window",
+                "held": "kept it for that session, whose inbox is full, and the broker delivers it when there is room",
+            }.get(delivered.disposition, "took it")
+            return f"Delivered to {peer.handle} (id {peer.session_id}); it {said}."
+
+        return send_message
+
+    def _history_tool(self) -> AgentTool:
+        """Create the tool that reads what was said before."""
+        messenger = self.messenger
+
+        @tool(name=MESSAGE_HISTORY_TOOL_NAME)
+        async def message_history(session: str = "", group: str = "", limit: int = 20) -> str:
+            """Read the messages this session exchanged earlier with one other session, or what was said in a group
+            chat you are in. The broker keeps them across restarts, so this also shows what was said before either
+            session was restarted. You see only your own conversations.
+
+            Args:
+                session: The other session: its name or id, from list_sessions or from an earlier message. Give this
+                    or group, or neither to see your most recent messages with everyone.
+                group: A group chat you are in, such as "review".
+                limit: How many of the newest messages to show, 1 to 100 (default 20).
+
+            Snippet:
+                message_history(session="fix-parser")
+                message_history(group="review", limit=50)
+
+            Guidelines:
+                - Use it to recall what you and another session already agreed before you write to them again.
+                - Messages are shown oldest first; a long one is cut.
+            """
+            if session and group:
+                raise ValueError("give 'session' or 'group', not both")
+            try:
+                messages, _ = await messenger.history(with_=session, group=group, limit=max(1, min(limit, 100)))
+            except SendError as error:
+                raise ValueError(_sentence(error)) from error
+            if not messages:
+                return "No messages yet."
+            me = messenger.client.session.session_id if messenger.client.session is not None else ""
+            lines = [f"{len(messages)} message{'s' if len(messages) != 1 else ''}, oldest first:"]
+            for item in messages:
+                sender = item.get("from", {})
+                to = item.get("to", {})
+                who = "you" if sender.get("session_id") == me else f"@{sender.get('handle', '?')}"
+                if to.get("kind") == "group":
+                    where = f"#{to.get('name', '?')}"
+                else:
+                    where = "you" if to.get("session_id") == me else f"@{to.get('handle', '?')}"
+                text = str(item.get("text", ""))
+                if len(text) > HISTORY_TEXT:
+                    text = f"{text[:HISTORY_TEXT]}... [{len(text)} characters]"
+                when = time.strftime("%Y-%m-%d %H:%M", time.localtime(float(item.get("ts", 0))))
+                lines.append(f"[{when}] {who} -> {where}: {text}")
+            return "\n".join(lines)
+
+        return message_history
+
+    def _group_tool(self) -> AgentTool:
+        """Create the tool that makes and changes group chats."""
+        messenger = self.messenger
+
+        @tool(name=MANAGE_GROUP_TOOL_NAME)
+        async def manage_group(action: str, group: str, members: str = "") -> str:
+            """Create or change a group chat of sessions. A message sent to a group (send_message with group=...)
+            reaches every other member that is connected. You become a member of a group you create, and only a
+            member may write to it or change it.
+
+            Args:
+                action: "create" (new group with you and the members), "add" (add members), "remove" (remove members),
+                    "leave" (take yourself out), or "delete" (remove the group; what was said stays in the history).
+                group: The group's name: letters, digits, '-' or '_', such as "review".
+                members: For create, add and remove: session names or ids from list_sessions, separated by commas.
+
+            Snippet:
+                manage_group(action="create", group="review", members="fix-parser, docs")
+                manage_group(action="leave", group="review")
+
+            Guidelines:
+                - Create a group only when your user asked for one, or when several sessions work on one task together.
+                - A group with no member left is deleted.
+            """
+            names = [part.strip() for part in members.split(",") if part.strip()]
+            try:
+                found = await messenger.manage_group(action, group, names)
+            except SendError as error:
+                raise ValueError(_sentence(error)) from error
+            if found is None:
+                return f"Group #{group.lstrip('#').lower()} no longer exists."
+            roster = {entry.session_id: entry.handle for entry in messenger.client.roster}
+            who = ", ".join(roster.get(m, f"{m[:8]} (offline)") for m in found.members)
+            return (
+                f"Group #{found.name} has {len(found.members)} member{'s' if len(found.members) != 1 else ''}: {who}."
+            )
+
+        return manage_group
+
+
+__all__ = [
+    "LIST_SESSIONS_TOOL_NAME",
+    "MANAGE_GROUP_TOOL_NAME",
+    "MESSAGE_HISTORY_TOOL_NAME",
+    "SEND_MESSAGE_TOOL_NAME",
+    "SessionMessagingExtension",
+]