@zooid/transport-matrix 0.10.0 → 0.11.1

package/dist/index.d.ts

@@ -271,6 +271,13 @@ interface ThreadState {
      * Implicit triggers → Directional continuation.
      */
     callers: Record<string, string>;
+    /**
+     * Handoff arcs per sub-agent: the event ids of the agent→agent @mention
+     * messages that called it, in timeline order (last = current arc). Each
+     * call opens a fresh ACP session keyed `threadRoot|callEventId`
+     * ([[ZOD071]]). Append-only; rebuilt from the timeline after a restart.
+     */
+    handoffs: Record<string, string[]>;
 }
 interface MaybeEvent {
     type?: string;

package/dist/index.js

@@ -745,6 +745,16 @@ function buildUserPowerLevels(asUserId, admins, agents, roomAlias) {
 import { Hono } from "hono";
 import { timingSafeEqual } from "crypto";
 
+// src/session-keys.ts
+var HANDOFF_KEY_SEP = "|";
+function composeHandoffKey(threadRoot, callEventId) {
+  return `${threadRoot}${HANDOFF_KEY_SEP}${callEventId}`;
+}
+function sessionKeyFor(agentName, threadRoot, state) {
+  const arc = state?.handoffs[agentName]?.at(-1);
+  return arc ? composeHandoffKey(threadRoot, arc) : threadRoot;
+}
+
 // src/event-encoders.ts
 var RAW_INPUT_STR_MAX = 250;
 function toToolCallBody(evt) {
@@ -1312,8 +1322,22 @@ function createMatrixTransport(opts) {
         return;
       }
       console.log(`[matrix] inbound dev.zooid.session_reset in ${evt.room_id} thread=${threadRoot}`);
+      if (!threadStates.has(threadRoot) && evt.room_id) {
+        try {
+          threadStates.set(
+            threadRoot,
+            await rebuildThreadState(client, evt.room_id, threadRoot, bindings)
+          );
+        } catch (err) {
+          console.warn(`[matrix] failed to rebuild threadState for reset ${threadRoot}:`, err);
+        }
+      }
+      const st = threadStates.get(threadRoot);
       for (const a of bindings) {
         agents.endSession(a.name, threadRoot);
+        for (const arc of st?.handoffs[a.name] ?? []) {
+          agents.endSession(a.name, composeHandoffKey(threadRoot, arc));
+        }
       }
       return;
     }
@@ -1402,7 +1426,7 @@ function createMatrixTransport(opts) {
     if (matches.length > 0 && promotedRoot) {
       let st = threadStates.get(promotedRoot);
       if (!st) {
-        st = { participants: [], rootMentions: [], callers: {} };
+        st = { participants: [], rootMentions: [], callers: {}, handoffs: {} };
         threadStates.set(promotedRoot, st);
       }
       const msgMentions = new Set(extractMentions(evt));
@@ -1410,7 +1434,13 @@ function createMatrixTransport(opts) {
       for (const a of bindings) {
         if (!msgMentions.has(a.userId)) continue;
         if (!st.rootMentions.includes(a.name)) st.rootMentions.push(a.name);
-        if (senderAgent && a.name !== senderAgent.name) st.callers[a.name] = senderAgent.name;
+        if (senderAgent && a.name !== senderAgent.name) {
+          st.callers[a.name] = senderAgent.name;
+          if (evt.event_id) {
+            const arcs = st.handoffs[a.name] ??= [];
+            if (!arcs.includes(evt.event_id)) arcs.push(evt.event_id);
+          }
+        }
       }
     }
     for (const a of matches) {
@@ -1419,7 +1449,7 @@ function createMatrixTransport(opts) {
         if (!promotedRoot) return;
         let st = threadStates.get(promotedRoot);
         if (!st) {
-          st = { participants: [], rootMentions: [], callers: {} };
+          st = { participants: [], rootMentions: [], callers: {}, handoffs: {} };
           threadStates.set(promotedRoot, st);
         }
         if (st.participants.at(-1) !== a.name) st.participants.push(a.name);
@@ -1492,8 +1522,8 @@ function createMatrixTransport(opts) {
     if (!evt.room_id || !evt.event_id) return;
     const inbound = inboundThreadRoot2(evt);
     const threadRoot = inbound ?? evt.event_id;
-    const sessionKey = threadRoot;
-    const sessionId = await agents.ensureSession(agent.name, sessionKey, evt.room_id);
+    const sessionKey = sessionKeyFor(agent.name, threadRoot, threadStates.get(threadRoot));
+    const sessionId = await agents.ensureSession(agent.name, sessionKey, evt.room_id, threadRoot);
     sessions.set(sessionId, { agent, roomId: evt.room_id, threadRoot });
     buffers.set(sessionId, "");
     bufferMessageIds.delete(sessionId);
@@ -1541,6 +1571,7 @@ function createMatrixTransport(opts) {
       await agents.prompt(agent.name, {
         threadId: sessionKey,
         channelId: evt.room_id,
+        contextThreadId: threadRoot,
         content: [...blocks, { type: "text", text: fullPromptText }]
       });
       const drainStart = Date.now();
@@ -1595,7 +1626,7 @@ function createMatrixTransport(opts) {
   };
 }
 async function rebuildThreadState(client, roomId, rootEventId, bindings) {
-  const state = { participants: [], rootMentions: [], callers: {} };
+  const state = { participants: [], rootMentions: [], callers: {}, handoffs: {} };
   const asUser = (bindings.find((b) => b.rooms.some((r) => r.alias === roomId)) ?? bindings[0])?.userId;
   if (!asUser) return state;
   const root = await client.fetchEvent(roomId, rootEventId, asUser);
@@ -1606,7 +1637,11 @@ async function rebuildThreadState(client, roomId, rootEventId, bindings) {
     for (const a of bindings) {
       if (!rootMentions.has(a.userId)) continue;
       if (!state.rootMentions.includes(a.name)) state.rootMentions.push(a.name);
-      if (rootSenderAgent && a.name !== rootSenderAgent.name) state.callers[a.name] = rootSenderAgent.name;
+      if (rootSenderAgent && a.name !== rootSenderAgent.name) {
+        state.callers[a.name] = rootSenderAgent.name;
+        const arcs = state.handoffs[a.name] ??= [];
+        if (!arcs.includes(rootEventId)) arcs.push(rootEventId);
+      }
     }
   }
   const { chunk: thread } = await client.fetchThreadRelations({
@@ -1618,10 +1653,17 @@ async function rebuildThreadState(client, roomId, rootEventId, bindings) {
     const mentions = new Set(extractMentions(ev));
     const evSender = ev.sender;
     const evSenderAgent = evSender ? bindings.find((b) => b.userId === evSender) : void 0;
+    const evId = ev.event_id;
     for (const a of bindings) {
       if (!mentions.has(a.userId)) continue;
       if (!state.rootMentions.includes(a.name)) state.rootMentions.push(a.name);
-      if (evSenderAgent && a.name !== evSenderAgent.name) state.callers[a.name] = evSenderAgent.name;
+      if (evSenderAgent && a.name !== evSenderAgent.name) {
+        state.callers[a.name] = evSenderAgent.name;
+        if (evId) {
+          const arcs = state.handoffs[a.name] ??= [];
+          if (!arcs.includes(evId)) arcs.push(evId);
+        }
+      }
     }
     const type = ev.type;
     if (type === "m.room.message" && evSender) {