@zooid/transport-matrix 0.12.0 → 0.13.0

package/dist/index.d.ts

@@ -177,7 +177,18 @@ declare class MatrixClient {
 
 interface MatrixContextProviderOpts {
     client: MatrixClient;
-    /** AS sender_localpart user (read access). */
+    /**
+     * The **agent's own** Matrix user (`@{workstation}.{name}:server`), which
+     * every read is impersonated as via `?user_id=`. Not the AS bot: that would
+     * read every room on the homeserver and make this class the only thing
+     * standing between an agent and someone else's conversation.
+     *
+     * This is load-bearing. It is what makes the homeserver — not our own
+     * bookkeeping — the authorization boundary for context reads, so a room or
+     * thread the agent is not in fails at Matrix with 403/404. Anything that
+     * widens who can name a room (a CLI, a new tool parameter) is safe only
+     * while this holds.
+     */
     asUserId: string;
     /** Map of Matrix user IDs → agent names, for is_agent / agent_name flags. */
     agentBots: Map<string, string>;

package/dist/index.js

@@ -331,7 +331,8 @@ var MatrixContextProvider = class {
     const threads = [];
     for (const ev of chunk) {
       if (ev.type !== "m.room.message") continue;
-      if (ev.content?.msgtype !== "m.text" || typeof ev.content.body !== "string") continue;
+      if (ev.content?.msgtype !== "m.text" && ev.content?.msgtype !== "m.notice" || typeof ev.content.body !== "string")
+        continue;
       const relatesTo = ev.content["m.relates_to"];
       if (relatesTo?.rel_type === "m.thread") continue;
       const agent = this.opts.agentBots.get(ev.sender);
@@ -405,7 +406,7 @@ var MatrixContextProvider = class {
         ...threadId !== void 0 ? { thread_id: threadId } : {}
       };
     }
-    if (msgtype !== "m.text" || typeof body !== "string") return null;
+    if (msgtype !== "m.text" && msgtype !== "m.notice" || typeof body !== "string") return null;
     return {
       id: ev.event_id,
       sender: ev.sender,
@@ -821,7 +822,11 @@ var RECOVERY_URLS = {
 function toErrorBody(evt, threadRoot) {
   const msg = evt.message.slice(0, 250);
   const out = {
-    msgtype: "m.notice",
+    // No msgtype: dev.zooid.error is not m.room.message, so the field is
+    // meaningless here — it was a vestige of copying the message-body shape.
+    // Its presence used to force careful push-rule `before` positioning
+    // (ZNC025 §10); that positioning is kept regardless, since it also
+    // protects rules for event types that never carried the field.
     body: `\u26A0 [${evt.code}] ${msg}`,
     code: evt.code,
     message: msg,
@@ -836,6 +841,25 @@ function toErrorBody(evt, threadRoot) {
   if (recovery) out.recovery = recovery;
   return out;
 }
+var PREVIEW_MAX = 140;
+function toTurnEndBody(evt, threadRoot) {
+  const preview = evt.lastMessage?.trim().replace(/\s+/g, " ");
+  return {
+    // `body` stays the turn-boundary summary: it is what a generic Matrix
+    // client renders for this event, and the prose is already its own message
+    // in the timeline. The preview below exists only for the push, which
+    // cannot see that message — agent prose is `m.notice`, deliberately
+    // silenced by `.m.rule.suppress_notices` so a chatty turn doesn't fire one
+    // push per chunk ([[ZNC025]] §10). Without it the only notification the
+    // user gets says an agent finished and nothing about what it said.
+    body: evt.producedOutput ? `${evt.agentId} finished` : `${evt.agentId} finished without output`,
+    ...preview ? { last_message: preview.slice(0, PREVIEW_MAX) } : {},
+    agent_id: evt.agentId,
+    session_id: evt.sessionId,
+    produced_output: evt.producedOutput,
+    "m.relates_to": { rel_type: "m.thread", event_id: threadRoot }
+  };
+}
 
 // src/transport.ts
 import { classify } from "@zooid/acp-client";
@@ -1153,7 +1177,11 @@ function createMatrixTransport(opts) {
   const pendingCommands = /* @__PURE__ */ new Map();
   const buildTextContent = (text) => {
     const content = {
-      msgtype: "m.text",
+      // m.notice, not m.text: .m.rule.suppress_notices silences the
+      // chunk-storm of agent prose server-side (ZNC025 §10) instead of every
+      // client having to filter it. dev.zooid.error carries the same tweak
+      // for the same reason.
+      msgtype: "m.notice",
       body: text
     };
     const html = toMatrixHtml(text);
@@ -1167,11 +1195,13 @@ function createMatrixTransport(opts) {
     }
     return content;
   };
+  const lastFlushed = /* @__PURE__ */ new Map();
   const flushBuffer = (sessionId) => {
     const ctx = sessions.get(sessionId);
     const text = buffers.get(sessionId) ?? "";
     if (!ctx || text.length === 0) return false;
     buffers.set(sessionId, "");
+    lastFlushed.set(sessionId, text);
     flushedCounts.set(sessionId, (flushedCounts.get(sessionId) ?? 0) + 1);
     const content = buildTextContent(text);
     const tail = (sendQueue.get(sessionId) ?? Promise.resolve()).then(async () => {
@@ -1584,19 +1614,30 @@ function createMatrixTransport(opts) {
         drained = next;
       }
       flushBuffer(sessionId);
+    } finally {
+      clearInterval(refresh);
+      await safeTyping(false);
+      await safePresence("online");
       await (sendQueue.get(sessionId) ?? Promise.resolve());
-      if ((flushedCounts.get(sessionId) ?? 0) === 0) {
+      const producedOutput = (flushedCounts.get(sessionId) ?? 0) > 0;
+      if (!producedOutput) {
         console.warn(
           `[matrix:${agent.name}] turn finished with empty buffer (session=${sessionId}); nothing sent to ${evt.room_id}`
         );
       }
-    } finally {
-      clearInterval(refresh);
-      await safeTyping(false);
-      await safePresence("online");
+      await client.sendCustomEvent({
+        roomId: evt.room_id,
+        asUserId: agent.userId,
+        eventType: "dev.zooid.turn.end",
+        content: toTurnEndBody(
+          { agentId: agent.name, sessionId, producedOutput, lastMessage: lastFlushed.get(sessionId) },
+          threadRoot
+        )
+      }).catch((e) => console.warn(`[matrix:${agent.name}] turn.end send failed:`, e));
       buffers.delete(sessionId);
       bufferMessageIds.delete(sessionId);
       flushedCounts.delete(sessionId);
+      lastFlushed.delete(sessionId);
       sendQueue.delete(sessionId);
     }
   }