@haikit/server 0.17.0 → 0.19.0

package/src/routes.ts

@@ -22,7 +22,7 @@ export function nodeHandler(hai: Hai, basePath = "/hai") {
     if (!url.pathname.startsWith(basePath)) return false;
     const route = url.pathname.slice(basePath.length);
 
-    if (req.method === "GET" && route === "/events" && hai.sendsNotices) {
+    if (req.method === "GET" && route === "/events" && hai.streamsEvents) {
       await streamNotices(hai, req, res, url);
       return true;
     }
@@ -59,7 +59,7 @@ export function nodeHandler(hai: Hai, basePath = "/hai") {
         type: "hello",
         conversationId: conversation.id,
         model: hai.config.model.id,
-        ...(hai.sendsNotices ? { events: true as const } : {}),
+        ...(hai.streamsEvents ? { events: true as const } : {}),
       });
     }
 
@@ -195,6 +195,32 @@ async function streamNotices(hai: Hai, req: IncomingMessage, res: ServerResponse
   // turn, not only the one whose attempt won the lease: another tab shows the
   // reply too, and holds its requests until the turn lets go.
   watchers.streams.add(emit);
+  // Signals from here on, starting with each one's latest; and it counts as
+  // present. A signal only matters as its latest value, so a reader that has
+  // fallen behind is sent just the newest of each once it catches up: a
+  // stalled socket holds at most one per signal, never every one sent.
+  const behind = new Map<string, WireEvent>();
+  let draining = false;
+  const flush = () => {
+    draining = false;
+    const pending = [...behind.values()];
+    behind.clear();
+    for (const event of pending) emitSignal(event);
+  };
+  const emitSignal: Emit = (event) => {
+    if (event.type !== "signal") return emit(event);
+    if (signal.aborted || res.writableEnded) return;
+    if (res.writableNeedDrain || behind.size) {
+      behind.set(event.name, event);
+      if (!draining) {
+        draining = true;
+        res.once("drain", flush);
+      }
+      return;
+    }
+    res.write(`data: ${JSON.stringify(event)}\n\n`);
+  };
+  const closeStream = hai.streamOpened(conversationId, emitSignal);
   // Joining while a wake turn runs: what it has shown so far, starting with
   // its `streaming` status, so the browser holds requests until it lets go,
   // and the reply's later text has a block to land in.
@@ -232,6 +258,33 @@ async function streamNotices(hai: Hai, req: IncomingMessage, res: ServerResponse
       });
   };
 
+  // An update notice goes out as the revision it announces: the surface, with
+  // how long ago it was stored, and its props. Only the last frame carries the
+  // notice's id, so a stream cut off between the two resumes with both. A
+  // revision whose payload is gone, swept with an old conversation's, is
+  // passed over with its id alone, so a browser resumes after it rather than
+  // being sent it again on every reconnect.
+  const sendRevision = async (handle: string, replaces: string, seq: number) => {
+    const record = await store.getPayload(handle, conversationId);
+    if (signal.aborted) return;
+    if (!record) return write(`id: ${seq}\n\n`);
+    const window = typeof record.staleAfterMs === "number" ? record.staleAfterMs : undefined;
+    const open: WireEvent = {
+      type: "ui_open",
+      handle,
+      // no tool call made it: the browser keeps the row of the one it replaces
+      toolId: "",
+      component: record.component,
+      version: record.version,
+      mode: record.mode,
+      ...(window === undefined ? {} : { staleAfterMs: window }),
+      ageMs: Math.max(0, Date.now() - record.createdAt),
+      replaces,
+    };
+    await write(`data: ${JSON.stringify(open)}\n\n`);
+    await write(`id: ${seq}\ndata: ${JSON.stringify({ type: "ui_props", handle, props: record.props } satisfies WireEvent)}\n\n`);
+  };
+
   // Everything after `after`, a page at a time, until a page comes back short.
   // A conversation deleted since the stream opened ends it: there is nothing
   // more to wait for, and the browser's reconnect is then refused.
@@ -243,6 +296,12 @@ async function streamNotices(hai: Hai, req: IncomingMessage, res: ServerResponse
       for (const n of records) {
         if (signal.aborted) return;
         if (n.seq <= after) continue;
+        if (n.replaces !== undefined && n.handle !== undefined) {
+          await sendRevision(n.handle, n.replaces, n.seq);
+          after = n.seq;
+          woken ||= n.kind === "wake";
+          continue;
+        }
         const event: WireEvent = {
           type: "notice",
           seq: n.seq,
@@ -263,8 +322,17 @@ async function streamNotices(hai: Hai, req: IncomingMessage, res: ServerResponse
 
   // a heartbeat is only for a stream gone quiet, never one already backed up
   const heartbeat = setInterval(() => res.writableNeedDrain || res.write(": ping\n\n"), HEARTBEAT_MS);
-  const wakes = wakeups(store.watch?.(conversationId, signal), signal)[Symbol.asyncIterator]();
+  // An app that sends no notices has nothing stored to read: the stream is only
+  // for signals, and stays open, reading nothing, until the browser leaves.
+  const wakes = hai.sendsNotices ? wakeups(store.watch?.(conversationId, signal), signal)[Symbol.asyncIterator]() : null;
   try {
+    if (!wakes) {
+      await new Promise<void>((resolve) => {
+        if (signal.aborted) resolve();
+        else signal.addEventListener("abort", () => resolve(), { once: true });
+      });
+      return;
+    }
     await catchUp(first);
     // A wake notice may be waiting from before this browser connected: one
     // that arrived while nobody watched, or while the conversation was busy.
@@ -281,9 +349,10 @@ async function streamNotices(hai: Hai, req: IncomingMessage, res: ServerResponse
   } finally {
     clearInterval(heartbeat);
     aborter.abort();
+    closeStream();
     watchers.streams.delete(emit);
     if (!watchers.streams.size) forgetWatchers(hai, conversationId, watchers);
-    await wakes.return?.();
+    await wakes?.return?.();
     res.end();
   }
 }
@@ -338,7 +407,15 @@ function remember(shown: WireEvent[], event: WireEvent) {
     else {
       // A revision of a surface this turn showed takes its place: a stream
       // joining later sees the surface once, as it is now. Its old props go.
-      delete copy.replaces;
+      // It keeps `replaces`, so a browser that did see the old one swaps it in
+      // place rather than adding a second, and the old one's tool row, which
+      // the browser keeps through a revision too.
+      const before = shown[replaced] as Extract<WireEvent, { type: "ui_open" }>;
+      copy.toolId = before.toolId;
+      // and every handle the surface had before, for a browser that last saw
+      // one of those and missed the revisions between
+      const earlier = [...(before.alsoReplaces ?? []), ...(before.replaces === undefined ? [] : [before.replaces])];
+      if (earlier.length) copy.alsoReplaces = earlier;
       shown[replaced] = copy;
       for (let i = shown.length - 1; i >= 0; i--) {
         const e = shown[i];