agent-relay-server 0.120.2 → 0.120.3

package/src/sse.ts

@@ -1,4 +1,5 @@
 import { getAgent, getOrchestrator, matchingDeliveryAgents, onWorkspaceChange, sendMessageWithResult, setChannelSubscriberProbe } from "./db";
+import { getOldestOutboxCursor, getOutboxCursor, replayEvents, type BusEvent } from "./bus-outbox";
 import { projectAgentStatusData } from "./agent-card-projection";
 import { emitRelayEvent, subscribeRelayEvents, type RelayEvent } from "./events";
 import { messageMatchesAgent, targetMatchesAgent } from "./agent-ref";
@@ -15,7 +16,7 @@ interface Connection {
   // Pending backpressure re-check. Set when a stream crosses the byte floor; cleared
   // once it drains or is closed after making no progress during the grace interval.
   drainCheck?: Timer;
-  drainCheckDesiredSize?: number | null;
+  drainCheckQueuedBytes?: number;
 }
 
 const connections = new Map<string, Connection>();
@@ -43,28 +44,36 @@ export function hasActiveSubscriber(agentId: string): boolean {
 }
 setChannelSubscriberProbe(hasActiveSubscriber);
 
-export function createSSEStream(agentId: string | null): Response {
+export function createSSEStream(agentId: string | null, lastEventId = 0): Response {
   let connId: string;
 
-  const stream = new ReadableStream<Uint8Array>({
-    start(controller) {
-      connId = crypto.randomUUID();
-      const keepalive = setInterval(() => {
-        const conn = connections.get(connId);
-        if (!conn) return;
-        sendEncoded(conn, encoder.encode(": keepalive\n\n"));
-      }, SSE_KEEPALIVE_MS);
-
-      connections.set(connId, { id: connId, agentId, controller, keepalive, queuedBytes: 0 });
-
-      controller.enqueue(encoder.encode(
-        `retry: ${SSE_RETRY_MS}\nevent: connected\ndata: ${JSON.stringify({ connectionId: connId })}\n\n`
-      ));
+  const stream = new ReadableStream<Uint8Array>(
+    {
+      start(controller) {
+        connId = crypto.randomUUID();
+        const keepalive = setInterval(() => {
+          const conn = connections.get(connId);
+          if (!conn) return;
+          sendEncoded(conn, encoder.encode(": keepalive\n\n"));
+        }, SSE_KEEPALIVE_MS);
+
+        connections.set(connId, { id: connId, agentId, controller, keepalive, queuedBytes: 0 });
+
+        const replay = replayPlan(lastEventId);
+        controller.enqueue(encoder.encode(
+          `retry: ${SSE_RETRY_MS}\nevent: connected\ndata: ${JSON.stringify({ connectionId: connId, replay })}\n\n`
+        ));
+        replayEventsToConnection(connections.get(connId), replay);
+      },
+      cancel() {
+        removeConnection(connId);
+      },
     },
-    cancel() {
-      removeConnection(connId);
+    {
+      highWaterMark: 0,
+      size: (chunk) => chunk?.byteLength ?? 0,
     },
-  });
+  );
 
   return new Response(stream, {
     headers: {
@@ -92,12 +101,19 @@ function closeConnection(id: string) {
   try { conn?.controller.close(); } catch {}
 }
 
-function sseFrame(event: string, data: unknown): Uint8Array {
-  return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+function sseFrame(event: string, data: unknown, id?: number): Uint8Array {
+  const idLine = id !== undefined ? `id: ${id}\n` : "";
+  return encoder.encode(`${idLine}event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+
+function bufferedBytes(conn: Connection): number {
+  const desiredSize = conn.controller.desiredSize;
+  if (desiredSize === null) return conn.queuedBytes;
+  return Math.max(0, -desiredSize);
 }
 
 function isBackpressured(conn: Connection): boolean {
-  return conn.queuedBytes >= SSE_MAX_QUEUED_BYTES && conn.controller.desiredSize !== null && conn.controller.desiredSize < 0;
+  return bufferedBytes(conn) >= SSE_MAX_QUEUED_BYTES;
 }
 
 function sendEncoded(conn: Connection, chunk: Uint8Array) {
@@ -108,31 +124,27 @@ function sendEncoded(conn: Connection, chunk: Uint8Array) {
     removeConnection(conn.id);
     return;
   }
-  if (conn.controller.desiredSize !== null && conn.controller.desiredSize >= 0) conn.queuedBytes = 0;
-  else conn.queuedBytes += chunk.byteLength;
+  conn.queuedBytes = bufferedBytes(conn);
   if (isBackpressured(conn)) scheduleDrainCheck(conn);
 }
 
 function scheduleDrainCheck(conn: Connection) {
   if (conn.drainCheck) return; // one deferred verdict per stream is enough
-  conn.drainCheckDesiredSize = conn.controller.desiredSize;
+  conn.drainCheckQueuedBytes = bufferedBytes(conn);
   conn.drainCheck = setTimeout(() => {
     conn.drainCheck = undefined;
     // The connection may already have been removed (cancel/close) during the grace —
     // closeConnection is idempotent, but bail early so we never touch a stale ref.
     if (connections.get(conn.id) !== conn) return;
-    const desiredSize = conn.controller.desiredSize;
-    if (desiredSize !== null && desiredSize >= 0) {
-      conn.queuedBytes = 0;
-      conn.drainCheckDesiredSize = undefined;
+    const queuedBytes = bufferedBytes(conn);
+    conn.queuedBytes = queuedBytes;
+    if (queuedBytes < SSE_MAX_QUEUED_BYTES) {
+      conn.drainCheckQueuedBytes = undefined;
       return;
     }
-    const improved = desiredSize !== null
-      && conn.drainCheckDesiredSize !== null
-      && conn.drainCheckDesiredSize !== undefined
-      && desiredSize > conn.drainCheckDesiredSize;
-    conn.drainCheckDesiredSize = undefined;
-    if (improved) {
+    const drained = conn.drainCheckQueuedBytes !== undefined && queuedBytes < conn.drainCheckQueuedBytes;
+    conn.drainCheckQueuedBytes = undefined;
+    if (drained) {
       scheduleDrainCheck(conn);
       return;
     }
@@ -140,30 +152,30 @@ function scheduleDrainCheck(conn: Connection) {
   }, SSE_DRAIN_GRACE_MS);
 }
 
-function send(conn: Connection, event: string, data: unknown) {
-  sendEncoded(conn, sseFrame(event, data));
+function send(conn: Connection, event: string, data: unknown, id?: number) {
+  sendEncoded(conn, sseFrame(event, data, id));
 }
 
 function fanout(event: RelayEvent): void {
   if (event.type === "message.new") {
-    sendNewMessage(event.data as unknown as Message);
+    sendNewMessage(event.data as unknown as Message, event.seq);
     return;
   }
   if (event.type === "task.updated" || event.type === "task.created" || event.type === "task.claimed" || event.type === "task.status") {
-    sendTaskChanged(event.data as unknown as Task, event.type);
+    sendTaskChanged(event.data as unknown as Task, event.type, event.seq);
     return;
   }
-  const chunk = sseFrame(event.type, event.data);
+  const chunk = sseFrame(event.type, event.data, event.seq);
   for (const conn of connections.values()) {
     sendEncoded(conn, chunk);
   }
 }
 
-function sendNewMessage(msg: Message): void {
+function sendNewMessage(msg: Message, seq?: number): void {
   const scopedBroadcastAgentIds = msg.to === "broadcast"
     ? new Set(matchingDeliveryAgents("broadcast", { from: msg.from, channel: msg.channel }).map((agent) => agent.id))
     : null;
-  const chunk = sseFrame("message.new", msg);
+  const chunk = sseFrame("message.new", msg, seq);
   const agentCache = new Map<string, AgentCard | null>();
   for (const conn of connections.values()) {
     if (!conn.agentId) {
@@ -279,8 +291,8 @@ export function emitMessageReactionUpdated(msg: Message) {
   emitRelayEvent({ type: "message.reaction_updated", source: "server", subject: String(msg.id), data: msg as unknown as Record<string, unknown> });
 }
 
-function sendTaskChanged(task: Task, eventType = "task.updated"): void {
-  const chunk = sseFrame(eventType, task);
+function sendTaskChanged(task: Task, eventType = "task.updated", seq?: number): void {
+  const chunk = sseFrame(eventType, task, seq);
   const agentCache = new Map<string, AgentCard | null>();
   for (const conn of connections.values()) {
     if (conn.agentId && !targetMatchesAgent(task.target, conn.agentId, fanoutAgent(conn.agentId, agentCache))) continue;
@@ -288,6 +300,60 @@ function sendTaskChanged(task: Task, eventType = "task.updated"): void {
   }
 }
 
+interface ReplayPlan {
+  requested: boolean;
+  since: number;
+  available: boolean;
+  gap: boolean;
+}
+
+function replayPlan(lastEventId: number): ReplayPlan {
+  const since = Number.isSafeInteger(lastEventId) && lastEventId > 0 ? lastEventId : 0;
+  if (since === 0) return { requested: false, since: 0, available: false, gap: false };
+  const oldest = getOldestOutboxCursor();
+  const gap = oldest > 0 && oldest > since + 1;
+  return { requested: true, since, available: !gap, gap };
+}
+
+function replayEventsToConnection(conn: Connection | undefined, plan: ReplayPlan): void {
+  if (!conn || !plan.requested) return;
+  if (plan.gap) {
+    send(conn, "replay.gap", { since: plan.since }, getOutboxCursor());
+    return;
+  }
+  const agentCache = new Map<string, AgentCard | null>();
+  for (const event of replayEvents(plan.since)) {
+    sendReplayEvent(conn, outboxToRelayEvent(event), agentCache);
+  }
+}
+
+function sendReplayEvent(conn: Connection, event: RelayEvent, agentCache: Map<string, AgentCard | null>): void {
+  if (event.type === "message.new" && conn.agentId) {
+    const msg = event.data as unknown as Message;
+    if (!messageMatchesAgent(msg, conn.agentId, fanoutAgent(conn.agentId, agentCache))) return;
+    send(conn, "message.new", msg, event.seq);
+    return;
+  }
+  if (event.type.startsWith("task.") && conn.agentId) {
+    const task = event.data as unknown as Task;
+    if (!targetMatchesAgent(task.target, conn.agentId, fanoutAgent(conn.agentId, agentCache))) return;
+    send(conn, event.type, task, event.seq);
+    return;
+  }
+  send(conn, event.type, event.data, event.seq);
+}
+
+function outboxToRelayEvent(event: BusEvent): RelayEvent {
+  return {
+    seq: event.seq,
+    type: event.eventType,
+    source: event.source,
+    subject: event.subject,
+    data: event.data,
+    timestamp: event.timestamp,
+  };
+}
+
 export function emitTaskChanged(task: Task, eventType = "task.updated") {
   emitRelayEvent({ type: eventType, source: task.source, subject: String(task.id), data: task as unknown as Record<string, unknown> });
 }

package/public/assets/formatted-body-C1AprxyU.js

@@ -1,3 +0,0 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["./formatted-body-impl-D_ZJQVNk.js","./chunk-CilyBKbf.js","./index-DfPouNiV.js","./preload-helper-C_JMBXql.js","./dist-DV83j9tm.js","./dist-ChDX_t12.js","./lucide-react-Dc3ZwCBi.js","./dist-Cs8X0P1d.js","./dist-CQ0Z-TDi.js","./react-dom-cLkVFBsS.js","./dist-mm7c7nBt.js","./dist-CDZZxxJq.js","./dist-BiLuYU6G.js","./dist-DyNJNwpi.js","./dist-D2jvo5oA.js","./es2015-VnZ2kVIz.js","./dist-CmFeEXMe.js","./dist-CBMWGhWc.js","./dist-y03IwOrd.js","./store-BaslPLIP.js","./display-exQDWum3.js","./types-uVOXgvMT.js","./agent-type-icon-BEz393ra.js","./copy-button-BStzXgtd.js","./button-C-V4oij1.js","./task-chip-kxk4eNm1.js","./badge-BhUZ1cAb.js","./input-CtLT7WXi.js","./themes-DjSwmAZN.js","./index-DcmG5gLR.css","./lib-ByLQqcD1.js","./lib-Cc7Il-6i.js"])))=>i.map(i=>d[i]);
-import{r as e}from"./chunk-CilyBKbf.js";import{hr as t,nr as n}from"./lucide-react-Dc3ZwCBi.js";import{t as r}from"./preload-helper-C_JMBXql.js";var i=e(t(),1),a=n(),o=(0,i.lazy)(()=>r(()=>import(`./formatted-body-impl-D_ZJQVNk.js`).then(e=>({default:e.FormattedBody})),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]),import.meta.url));function s(e){return(0,a.jsx)(i.Suspense,{fallback:(0,a.jsx)(`span`,{className:e.className,children:e.text}),children:(0,a.jsx)(o,{...e})})}export{s as t};
-//# sourceMappingURL=formatted-body-C1AprxyU.js.map