@kybernesis/buzz 0.10.1 → 0.10.2

package/dist/turn.d.ts

@@ -82,8 +82,17 @@ export declare function silentTurnReply(failures: readonly TurnFailure[]): strin
 export declare function describeSilentTurn(failures: readonly TurnFailure[]): string;
 /** Convert one inbound Buzz message into an eve-compatible turn. */
 export declare function composeMessage(text: string, attachments: MediaRef[], fetchAttachment: (ref: MediaRef) => Promise<FetchedMedia>, log?: (message: string) => void): Promise<TurnMessage>;
+/**
+ * How long reading the backlog of a conversation on record may take before the
+ * conversation is treated as gone. An idle session's unread events arrive in
+ * well under a second; a session whose durable run died under a runtime
+ * upgrade never finishes. On 2026-10-05 a Buzz channel's stored run had failed
+ * replay after the eve 0.68 cutover, and every message in that channel sat at
+ * "typing" with nothing reaching the agent, for as long as anyone waited.
+ */
+export declare const DEFAULT_UNREAD_DRAIN_TIMEOUT_MS = 20000;
 /** Continue a channel's existing conversation, replacing it only when it is explicitly stale. */
-export declare function answerTurn(client: Client, sessions: SessionStore, channel: string, message: TurnMessage, community: string, log?: (message: string) => void, agentSilenceTimeoutMs?: number, agentWorkTimeoutMs?: number): Promise<TurnOutcome>;
+export declare function answerTurn(client: Client, sessions: SessionStore, channel: string, message: TurnMessage, community: string, log?: (message: string) => void, agentSilenceTimeoutMs?: number, agentWorkTimeoutMs?: number, unreadDrainTimeoutMs?: number): Promise<TurnOutcome>;
 /** What the room is told when eve refuses the turn itself. */
 /**
  * The two answers from eve that mean the stored session cannot carry another

package/dist/turn.js

@@ -313,12 +313,23 @@ async function sendExisting(responsePromise, streamIndex, timeouts, continueStre
         watchdog.dispose();
     }
 }
+/**
+ * How long reading the backlog of a conversation on record may take before the
+ * conversation is treated as gone. An idle session's unread events arrive in
+ * well under a second; a session whose durable run died under a runtime
+ * upgrade never finishes. On 2026-10-05 a Buzz channel's stored run had failed
+ * replay after the eve 0.68 cutover, and every message in that channel sat at
+ * "typing" with nothing reaching the agent, for as long as anyone waited.
+ */
+export const DEFAULT_UNREAD_DRAIN_TIMEOUT_MS = 20_000;
 /** Continue a channel's existing conversation, replacing it only when it is explicitly stale. */
-export async function answerTurn(client, sessions, channel, message, community, log = () => { }, agentSilenceTimeoutMs = DEFAULT_AGENT_SILENCE_TIMEOUT_MS, agentWorkTimeoutMs = DEFAULT_AGENT_WORK_TIMEOUT_MS) {
+export async function answerTurn(client, sessions, channel, message, community, log = () => { }, agentSilenceTimeoutMs = DEFAULT_AGENT_SILENCE_TIMEOUT_MS, agentWorkTimeoutMs = DEFAULT_AGENT_WORK_TIMEOUT_MS, unreadDrainTimeoutMs = DEFAULT_UNREAD_DRAIN_TIMEOUT_MS) {
     const intervalMs = {
         silenceMs: validateAgentSilenceTimeoutMs(agentSilenceTimeoutMs),
         workMs: validateAgentSilenceTimeoutMs(agentWorkTimeoutMs),
     };
+    // Never longer than the silence bound, so a caller that tightened silence tightened this too.
+    const drainMs = Math.min(validateAgentSilenceTimeoutMs(unreadDrainTimeoutMs), intervalMs.silenceMs);
     const existing = sessions.get(community, channel);
     if (existing) {
         try {
@@ -330,8 +341,24 @@ export async function answerTurn(client, sessions, channel, message, community,
              * `send()` opens its response stream at the position the handle already
              * holds and stops at the FIRST turn boundary it meets. Draining first
              * repairs any cursor that was left behind by a prior disconnected reader.
+             * Bounded on its own, tightly: this read is of a backlog, not of work.
+             * A backlog that does not finish is not proof of anything by itself —
+             * the run behind it may be dead (eve 0.68 cutover, 2026-10-05: a stored
+             * run that failed replay streamed nothing, and the channel sat at
+             * "typing" for good) or the transport may be having a moment. So the
+             * stall is logged and the send goes ahead: the agent's answer to the
+             * send decides. 404 / "no longer active" replaces the session below; a
+             * real reply continues it; a transport failure preserves it.
              */
-            const unread = await drainUnread((signal) => session.stream({ follow: false, startIndex: existing.streamIndex, signal }), intervalMs);
+            let unread = 0;
+            try {
+                unread = await drainUnread((signal) => session.stream({ follow: false, startIndex: existing.streamIndex, signal }), { silenceMs: drainMs, workMs: drainMs });
+            }
+            catch (error) {
+                if (!(error instanceof AgentSilenceTimeoutError))
+                    throw error;
+                log(`backlog of ${channel.slice(0, 8)} (${existing.id}) did not finish reading in ${drainMs}ms; asking the agent directly`);
+            }
             if (unread > 0) {
                 log(`caught up on ${unread} unread event(s) in ${channel.slice(0, 8)} before answering`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/buzz",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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",