@aexhq/sdk 0.46.3-canary → 0.46.5-canary

package/dist/_contracts/event-stream-client.js

@@ -45,8 +45,19 @@ export function hasRunTerminalType(event) {
  * the coordinator's pair (platform `packages/shared/src/event-stream-client.ts`).
  */
 const COORDINATOR_PING = "aex:ping";
-/** Post-open replay request; $connect cannot safely PostToConnection before the handshake completes. */
-const COORDINATOR_REPLAY = JSON.stringify({ action: "replay" });
+/**
+ * Pull request for everything from `nextSequence` onward.
+ *
+ * Sent on open ($connect cannot safely PostToConnection before the handshake
+ * completes) and again whenever a frame declares a predecessor this client has
+ * not reached. Catch-up is PULL-based because the connection row holds only the
+ * server's BELIEF about what reached the socket: a frame that was posted but
+ * never arrived leaves the client behind that belief with no way for the server
+ * to notice. Naming the cursor makes the client authoritative about what it
+ * actually holds. An older coordinator ignores the extra field and falls back to
+ * its own high-water, so sending it is safe against any deployed server.
+ */
+const replayFrom = (nextSequence) => JSON.stringify({ action: "replay", from: nextSequence });
 /** Default half-open watchdog window — 3× the ping cadence, so 2 pongs can be lost. */
 const DEFAULT_IDLE_TIMEOUT_MS = 45_000;
 /** Default client keep-alive ping cadence. */
@@ -98,6 +109,7 @@ export async function* streamCoordinatorEvents(opts) {
         const ws = makeWs(url.toString());
         const pending = [];
         const seenSequences = new Set();
+        const catchUp = createCatchUp(ws, cursor);
         let closed = false;
         let disconnectReason = "";
         let resolveNext = null;
@@ -199,15 +211,7 @@ export async function* streamCoordinatorEvents(opts) {
         };
         ws.addEventListener("open", () => {
             armIdle();
-            if (typeof ws.send === "function") {
-                try {
-                    ws.send(COORDINATOR_REPLAY);
-                }
-                catch {
-                    // socket not open / send unsupported — the DDB-stream replay kicker and
-                    // quiet-reconnect path still cover replay.
-                }
-            }
+            catchUp.request();
             if (pingIntervalMs > 0 && typeof ws.send === "function") {
                 pingTimer = timerPort.setInterval(() => {
                     try {
@@ -232,6 +236,11 @@ export async function* streamCoordinatorEvents(opts) {
                 if (isReplayableEvent(evt)) {
                     if (evt.sequence <= cursor || seenSequences.has(evt.sequence))
                         return;
+                    // A frame the client cannot chain is refused, leaving both the cursor
+                    // and `seenSequences` untouched so the pull's copy of it is not later
+                    // suppressed as a duplicate.
+                    if (!catchUp.chains(evt))
+                        return;
                     seenSequences.add(evt.sequence);
                 }
                 else if (!rememberLiveId(evt.id)) {
@@ -325,6 +334,64 @@ export async function* streamCoordinatorEvents(opts) {
         await sleep(reconnectDelayMs, timerPort, opts.signal);
     }
 }
+/**
+ * The exclusive lower bound the coordinator declared for a durable frame: the
+ * sequence of the public event immediately preceding it in journal projection
+ * order (`-1` when the frame opens the session).
+ *
+ * Transport-only — it describes this frame's position in the stream, not the
+ * event, so it is never part of the durable {@link AexEvent} the archive returns.
+ * Absent means the producer made no claim (an older coordinator, or a path that
+ * cannot prove what came before it), and an unproven link is not a gap: the
+ * frame is accepted exactly as it was before this check existed.
+ */
+function declaredPredecessor(frame) {
+    const value = frame.prevSequence;
+    return typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
+}
+/**
+ * Per-connection catch-up bookkeeping.
+ *
+ * The high-water is RECEIPT-side — the highest durable sequence admitted on this
+ * connection, including frames still queued for the consumer. The gap check has
+ * to run against that and not against the yield-side cursor, which lags while
+ * the consumer drains: a contiguous burst landing in one turn would otherwise
+ * report every frame after the first as a hole.
+ *
+ * One pull is outstanding per high-water position, so a run of unchainable
+ * frames costs one request rather than one per frame; it re-arms by
+ * construction, since the next gap at a moved position names a different one.
+ */
+function createCatchUp(ws, cursor) {
+    let accepted = cursor;
+    let pulledFrom = null;
+    const request = () => {
+        const from = accepted + 1;
+        if (pulledFrom === from || typeof ws.send !== "function")
+            return;
+        pulledFrom = from;
+        try {
+            ws.send(replayFrom(from));
+        }
+        catch {
+            // socket not open / send unsupported — the idle + quiet watchdogs still
+            // reconnect, and a reconnect resumes from the cursor anyway.
+        }
+    };
+    return {
+        request,
+        chains: (frame) => {
+            const predecessor = declaredPredecessor(frame);
+            if (predecessor !== undefined && predecessor > accepted) {
+                request();
+                return false;
+            }
+            if (frame.sequence > accepted)
+                accepted = frame.sequence;
+            return true;
+        }
+    };
+}
 function isCoordinatorStreamEvent(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;

package/dist/cli.mjs

@@ -3501,7 +3501,7 @@ function hasRunTerminalType(event) {
   return event.type === "RUN_FINISHED" || event.type === "RUN_ERROR";
 }
 var COORDINATOR_PING = "aex:ping";
-var COORDINATOR_REPLAY = JSON.stringify({ action: "replay" });
+var replayFrom = (nextSequence) => JSON.stringify({ action: "replay", from: nextSequence });
 var DEFAULT_IDLE_TIMEOUT_MS = 45e3;
 var DEFAULT_PING_INTERVAL_MS = 15e3;
 var DEFAULT_EVENT_QUIET_RECHECK_MS = 9e4;
@@ -3546,6 +3546,7 @@ async function* streamCoordinatorEvents(opts) {
     const ws = makeWs(url.toString());
     const pending = [];
     const seenSequences = /* @__PURE__ */ new Set();
+    const catchUp = createCatchUp(ws, cursor);
     let closed = false;
     let disconnectReason = "";
     let resolveNext = null;
@@ -3639,12 +3640,7 @@ async function* streamCoordinatorEvents(opts) {
     };
     ws.addEventListener("open", () => {
       armIdle();
-      if (typeof ws.send === "function") {
-        try {
-          ws.send(COORDINATOR_REPLAY);
-        } catch {
-        }
-      }
+      catchUp.request();
       if (pingIntervalMs > 0 && typeof ws.send === "function") {
         pingTimer = timerPort.setInterval(() => {
           try {
@@ -3667,6 +3663,8 @@ async function* streamCoordinatorEvents(opts) {
         if (isReplayableEvent(evt)) {
           if (evt.sequence <= cursor || seenSequences.has(evt.sequence))
             return;
+          if (!catchUp.chains(evt))
+            return;
           seenSequences.add(evt.sequence);
         } else if (!rememberLiveId(evt.id)) {
           return;
@@ -3742,6 +3740,37 @@ async function* streamCoordinatorEvents(opts) {
     await sleep(reconnectDelayMs, timerPort, opts.signal);
   }
 }
+function declaredPredecessor(frame) {
+  const value = frame.prevSequence;
+  return typeof value === "number" && Number.isSafeInteger(value) ? value : void 0;
+}
+function createCatchUp(ws, cursor) {
+  let accepted = cursor;
+  let pulledFrom = null;
+  const request = () => {
+    const from = accepted + 1;
+    if (pulledFrom === from || typeof ws.send !== "function")
+      return;
+    pulledFrom = from;
+    try {
+      ws.send(replayFrom(from));
+    } catch {
+    }
+  };
+  return {
+    request,
+    chains: (frame) => {
+      const predecessor = declaredPredecessor(frame);
+      if (predecessor !== void 0 && predecessor > accepted) {
+        request();
+        return false;
+      }
+      if (frame.sequence > accepted)
+        accepted = frame.sequence;
+      return true;
+    }
+  };
+}
 function isCoordinatorStreamEvent(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;

package/dist/cli.mjs.sha256

@@ -1 +1 @@
-04c687d3f3d7cbaf6b923b5d969edc4c98de596229d944442e9b6a703c83fd69  cli.mjs
+a57352fbb791f3941e71e1c75b56cbe77a1c7616be763c021fe5b37e316a9928  cli.mjs

package/dist/version.d.ts

@@ -6,4 +6,4 @@
  *
  * Used by the (future) User-Agent header on outbound SDK requests.
  */
-export declare const SDK_VERSION = "0.46.3-canary";
+export declare const SDK_VERSION = "0.46.5-canary";

package/dist/version.js

@@ -6,5 +6,5 @@
  *
  * Used by the (future) User-Agent header on outbound SDK requests.
  */
-export const SDK_VERSION = "0.46.3-canary";
+export const SDK_VERSION = "0.46.5-canary";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexhq/sdk",
-  "version": "0.46.3-canary",
+  "version": "0.46.5-canary",
   "description": "TypeScript SDK for autonomous agent sessions with managed Vercel AI Gateway model access.",
   "license": "Apache-2.0",
   "repository": {
@@ -55,6 +55,6 @@
     "zod": "4.4.3"
   },
   "aexRelease": {
-    "sourceSha": "37ad2edae1eac28f413615e25d50d330c45a4c2f"
+    "sourceSha": "b2bf9ebe5c7e86a89e37f48c9c93ef359252202e"
   }
 }