@kybernesis/buzz 0.4.3 → 0.5.0

package/dist/bridge.js

@@ -39,6 +39,13 @@ export function buzzBridge(options) {
      * same conversation through a client built for the person sending it, which
      * is what the runtime reads to decide whose memory and whose connections the
      * turn may touch.
+     *
+     * The stream position is kept beside the id for a reason that cost an
+     * afternoon: attaching defaults to index 0, so a turn reads the conversation
+     * from its beginning and reports the FIRST completed message it finds — the
+     * previous person's answer. The turn itself runs correctly, as the right
+     * person, against the right connections; only the text posted back is
+     * somebody else's, which is the most convincing way to look broken.
      */
     const sessions = new Map();
     /** Who has already been sent a link, so a room full of strangers is not a room full of spam. */
@@ -51,15 +58,60 @@ export function buzzBridge(options) {
         auth: { bearer: token },
         headers: bundle ? { "x-kybernesis-bundle": bundle } : {},
     });
+    /**
+     * One turn at a time per channel.
+     *
+     * Two people asking at once used to interleave: both turns read and wrote the
+     * same stored stream position, so one of them read the other's boundary and
+     * came back with the wrong answer or none. A channel is a conversation; its
+     * turns are ordered whether or not the people in it take turns.
+     */
+    const inFlight = new Map();
+    function serialize(channel, work) {
+        const queued = (inFlight.get(channel) ?? Promise.resolve()).then(work, work);
+        // Kept only while it matters: the chain holds the LAST promise, not a history.
+        inFlight.set(channel, queued.catch(() => { }));
+        return queued;
+    }
     async function ask(channel, text, token, bundle) {
         // Built per turn, for the person whose turn it is.
         const client = clientFor(token, bundle);
         const existing = sessions.get(channel);
         if (existing) {
             try {
-                const session = client.sessions.attach(existing);
+                const session = client.sessions.attach(existing.id, { streamIndex: existing.streamIndex });
+                /**
+                 * Move to the true end of the conversation before speaking.
+                 *
+                 * `send()` opens its response stream at the position the handle already
+                 * holds and stops at the FIRST turn boundary it meets. If anything is
+                 * still unread there — the tail of a turn that outlived its reader, a
+                 * turn that was running when the bridge restarted — that boundary
+                 * belongs to the older turn. The read ends on it, this turn's answer is
+                 * never collected, and the stored position stays one turn behind.
+                 *
+                 * Which makes it permanent: every later turn reads the previous turn's
+                 * tail. The channel answers nothing, then answers a question from ten
+                 * minutes ago, and a fresh conversation elsewhere works perfectly —
+                 * because a fresh conversation has nothing left over to trip on.
+                 *
+                 * Draining first costs one bounded read of only what is unread, and it
+                 * repairs a position that has already drifted rather than requiring
+                 * anyone to notice. Non-following, so it ends at the tail instead of
+                 * waiting for the future.
+                 */
+                let unread = 0;
+                for await (const _ of session.stream({ follow: false, startIndex: existing.streamIndex })) {
+                    unread += 1;
+                }
+                if (unread > 0) {
+                    log(`caught up on ${unread} unread event(s) in ${channel.slice(0, 8)} before answering`);
+                }
                 const response = await session.send(text);
-                return (await response.result()).message ?? "";
+                const result = await response.result();
+                // Where this turn left the conversation, so the next one starts after it.
+                sessions.set(channel, { id: existing.id, streamIndex: session.state.streamIndex });
+                return result.message ?? "";
             }
             catch (error) {
                 // A session the agent no longer holds cannot be resumed. Starting a new one loses the
@@ -69,8 +121,12 @@ export function buzzBridge(options) {
             }
         }
         const created = await client.sessions.create({ message: text });
-        sessions.set(channel, created.session.state.sessionId);
-        return (await created.response.result()).message ?? "";
+        const message = (await created.response.result()).message ?? "";
+        sessions.set(channel, {
+            id: created.session.state.sessionId,
+            streamIndex: created.session.state.streamIndex,
+        });
+        return message;
     }
     /**
      * Send someone the link that makes them known, privately.
@@ -156,9 +212,18 @@ export function buzzBridge(options) {
         void relay.react(event.id, SEEN);
         const stopTyping = relay.typingIn(channel);
         try {
-            const reply = await ask(channel, text, speaker.token, speaker.bundle);
+            const reply = await serialize(channel, () => ask(channel, text, speaker.token, speaker.bundle));
             if (!reply) {
-                log("the agent produced no text");
+                /**
+                 * Silence is the worst answer available.
+                 *
+                 * An empty result used to end here, with a line in a log nobody was
+                 * reading. In a room that is indistinguishable from the agent ignoring
+                 * you — so people ask again, which is how one unanswered question
+                 * became five, none of which looked like a fault to anyone watching.
+                 */
+                log(`no text for ${channel.slice(0, 8)} — telling them rather than going quiet`);
+                relay.reply(channel, "I didn't get an answer back for that one — ask me again and I'll retry.", event);
                 return;
             }
             relay.reply(channel, reply, event);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/buzz",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Put an eve agent in a Buzz workspace as a member: per-speaker verified identity resolved through the control plane, self-service identity linking, presence, typing and seen signals.",
   "license": "Apache-2.0",
   "type": "module",