@jskit-ai/assistant-runtime 0.1.237 → 0.1.238

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.237",
+  "version": "0.1.238",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -12,19 +12,19 @@
     "./server": "./src/server/index.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.243",
+    "@jskit-ai/assistant-core": "0.1.244",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.245",
-    "@jskit-ai/http-web": "0.1.95",
-    "@jskit-ai/kernel": "0.1.247",
-    "@jskit-ai/realtime": "0.1.247",
-    "@jskit-ai/shell-web": "0.1.254",
+    "@jskit-ai/http-runtime": "0.1.246",
+    "@jskit-ai/http-web": "0.1.96",
+    "@jskit-ai/kernel": "0.1.248",
+    "@jskit-ai/realtime": "0.1.248",
+    "@jskit-ai/shell-web": "0.1.255",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.247"
+    "@jskit-ai/database-runtime": "0.1.248"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/support/subscribeAssistantConversation.js

@@ -40,6 +40,10 @@ function subscribeAssistantConversation({
   let streaming = null;
   let reloadInFlight = null;
   let reloadQueued = false;
+  // A transient subscription failure retries while the socket stays connected;
+  // otherwise only the next connect would recover the chat.
+  let retryTimer = null;
+  let retryDelay = 1_000;
   const completed = new Map();
   const settledTurns = new Set();
   const pendingReads = new Set();
@@ -183,7 +187,12 @@ function subscribeAssistantConversation({
     if (epoch === null) pending.push(payload);
     else deliver(payload);
   }
+  function clearRetry() {
+    clearTimeout(retryTimer);
+    retryTimer = null;
+  }
   function subscribe({ preserveHistory = false } = {}) {
+    clearRetry();
     if (disposed || !socket.connected) return;
     const attempt = ++generation;
     epoch = null;
@@ -202,13 +211,18 @@ function subscribeAssistantConversation({
         listening = false;
         pending = [];
         if (socket.connected) socket.emit(ASSISTANT_CONVERSATION_UNSUBSCRIBE, { subscriptionId });
-        onError(error ? Object.assign(new Error("Chat updates could not reconnect. Reload chat to try again.", { cause: error }), {
+        if (error || response?.status >= 500) {
+          retryTimer = setTimeout(() => subscribe({ preserveHistory }), retryDelay);
+          retryDelay = Math.min(retryDelay * 2, 30_000);
+        }
+        onError(error ? Object.assign(new Error("Chat updates could not reconnect. Retrying automatically; Reload chat to try now.", { cause: error }), {
           code: "assistant_subscription_transport_failed"
         }) : Object.assign(new Error(response?.error || "Conversation subscription failed."), {
           code: response?.code, statusCode: response?.status
         }));
         return;
       }
+      retryDelay = 1_000;
       epoch = response.streamEpoch;
       receiveState(response.state, { initial: !preserveHistory, canonical: !preserveHistory });
       for (const payload of pending.sort((left, right) => left.streamRevision - right.streamRevision)) deliver(payload);
@@ -216,6 +230,7 @@ function subscribeAssistantConversation({
     });
   }
   function disconnected() {
+    clearRetry();
     generation += 1;
     epoch = null;
     pending = [];
@@ -231,6 +246,7 @@ function subscribeAssistantConversation({
   function release() {
     if (disposed) return;
     disposed = true;
+    clearRetry();
     generation += 1;
     pending = [];
     completed.clear();

package/test/assistantConversationSubscriptions.test.js

@@ -343,7 +343,7 @@ test("the real ten-second subscription deadline releases its late observer and R
   while (!view.errors.length || f.active() !== 0) {
     await once(f.changes, "change", { signal: AbortSignal.timeout(12_000) });
   }
-  assert.equal(view.errors[0].message, "Chat updates could not reconnect. Reload chat to try again.");
+  assert.equal(view.errors[0].message, "Chat updates could not reconnect. Retrying automatically; Reload chat to try now.");
   assert.equal(view.errors[0].cause.message, "operation has timed out");
   assert.equal(socket.id, socketId);
   assert.equal(socket.connected, true);
@@ -1012,6 +1012,70 @@ test("host subscription policy retains authenticated actor metadata and per-even
   assert.ok(cookies.every(value => value === "host-session"));
 });
 
+test("a transient subscription failure retries by itself while connected; denials never retry", t => {
+  // Production: after a laptop woke, the resubscribe acknowledgement missed its
+  // deadline while the socket stayed connected, and the chat stayed stuck.
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const socket = new EventEmitter();
+  socket.connected = true;
+  const requests = [], states = [], errors = [];
+  socket.timeout = () => ({ emit(name, input, acknowledge) { requests.push({ input, acknowledge }); } });
+  const dispose = subscribeAssistantConversation({ socket, conversationId: "chat", targetSurfaceId: "home", hostSurfaceId: "home",
+    read() {}, onState: state => states.push(state), onError: error => errors.push(error) });
+  const state = { id: "chat", conversationLog: [], streaming: { revision: 0, messages: [] } };
+  requests[0].acknowledge(new Error("operation has timed out"));
+  assert.match(errors[0].message, /Retrying automatically/u);
+  t.mock.timers.tick(999);
+  assert.equal(requests.length, 1);
+  t.mock.timers.tick(1);
+  assert.equal(requests.length, 2);
+  assert.deepEqual(requests[1].input, requests[0].input);
+  requests[1].acknowledge(null, { ok: false, error: "Retry shortly.", status: 503 });
+  t.mock.timers.tick(1_999);
+  assert.equal(requests.length, 2, "Each retry waits twice as long");
+  t.mock.timers.tick(1);
+  assert.equal(requests.length, 3);
+  requests[2].acknowledge(null, { ok: true, streamEpoch: "recovered", state });
+  assert.equal(states.length, 1);
+  // A reconnect replaces a pending retry, and success restarts the backoff.
+  socket.emit("disconnect");
+  socket.emit("connect");
+  requests[3].acknowledge(new Error("operation has timed out"));
+  socket.connected = false;
+  socket.emit("disconnect");
+  t.mock.timers.tick(60_000);
+  assert.equal(requests.length, 4, "A disconnected socket waits for its own reconnect");
+  socket.connected = true;
+  socket.emit("connect");
+  requests[4].acknowledge(null, { ok: false, error: "Access denied.", status: 403 });
+  t.mock.timers.tick(60_000);
+  assert.equal(requests.length, 5, "A denial never retries");
+  dispose.reload();
+  requests[5].acknowledge(new Error("operation has timed out"));
+  t.mock.timers.tick(999);
+  dispose();
+  t.mock.timers.tick(60_000);
+  assert.equal(requests.length, 6, "Disposal cancels the pending retry");
+});
+
+test("a retried resubscribe keeps the loaded history its caller preserved", t => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const socket = new EventEmitter();
+  socket.connected = true;
+  const requests = [], publications = [];
+  socket.timeout = () => ({ emit(name, input, acknowledge) { requests.push(acknowledge); } });
+  const subscription = subscribeAssistantConversation({ socket, conversationId: "chat", targetSurfaceId: "home", hostSurfaceId: "home",
+    read() {}, onState: (state, options) => publications.push(options) });
+  const state = { id: "chat", conversationLog: [], streaming: { revision: 0, messages: [] } };
+  requests[0](null, { ok: true, streamEpoch: "first", state });
+  subscription.reload({ resubscribe: true });
+  requests[1](new Error("operation has timed out"));
+  t.mock.timers.tick(1_000);
+  requests[2](null, { ok: true, streamEpoch: "second", state });
+  assert.deepEqual(publications, [{ initial: true, canonical: true }, { initial: false, canonical: false }]);
+  subscription();
+});
+
 for (const status of [401, 403, 503]) {
   test(`subscription read failure ${status} fences denied updates but retains transient history`, async t => {
     const changes = new EventEmitter();