@jskit-ai/assistant-runtime 0.2.1 → 0.2.2

package/README.md

@@ -34,7 +34,8 @@ modes) and `packages/agent-docs/site/guide/app-extras/assistant-conversation.md`
 With the existing realtime diagnostic option (`JSKIT_REALTIME_DEBUG=1`, or
 `config.realtime.debug=true`), conversation subscriptions emit one `pending`
 warning if admission/snapshot reading has not returned within the client's
-10-second acknowledgement budget. The warning names the current stage and the
+10-second budget, after which the client shows a loading notice and keeps waiting
+(it gives up only after 120 seconds). The warning names the current stage and the
 server-generated epoch; a conversation identity is included only after its
 successful authorized open. Observer release also records the current stage and
 reason. While diagnostics are enabled, every stage transition is recorded at

package/locales/en.json

@@ -130,7 +130,8 @@
     },
     "errors": {
       "assistant_history_inspection_required": "This conversation has ambiguous historical SQL rows. Inspect the reported rows offline before using the common runtime; no history was changed.",
-      "assistant_subscription_transport_failed": "Chat updates could not reconnect. Retrying automatically; Reload chat to try now."
+      "assistant_subscription_transport_failed": "Chat updates could not reconnect. Retrying automatically; Reload chat to try now.",
+      "assistant_subscription_waiting": "Chat is still loading. Waiting for the server; Reload chat to try now."
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -13,12 +13,12 @@
     "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.1",
+    "@jskit-ai/assistant-core": "0.2.2",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
     "@jskit-ai/http-runtime": "0.2.0",
-    "@jskit-ai/http-web": "0.2.0",
+    "@jskit-ai/http-web": "0.2.1",
     "@jskit-ai/kernel": "0.2.0",
     "@jskit-ai/realtime": "0.2.0",
     "@jskit-ai/shell-web": "0.2.0",

package/src/client/composables/useAssistantConversation.js

@@ -1009,10 +1009,15 @@ function createConversationBinding({ conversationId, endpoint = "", surfaceId =
       } else current.draft.value = "";
     }
     onSubmit?.();
+    const dispatch = () => prepare ? current.submitPrepared(captured, { messageId, onAccepted: acknowledge, prepare })
+      : current.send(captured, { messageId, onAccepted: acknowledge });
     // A restored uncertain receipt may have no retained acceptance callback.
-    // Inspection can acknowledge it, but must never run preparation or Send.
+    // Inspection can acknowledge it. Only the server's proof that the message
+    // never reached the AI (which marks it failed) lets Retry send it again.
     if (retry?.status === "uncertain") return current.inspectDelivery(messageId).then(receipt => {
       if (!current.current.value || !isCurrent()) return false;
+      if (receipt?.status === "not-sent" && receipt.messageId === messageId &&
+          current.delivery.find(messageId)?.status === "failed") return dispatch();
       if (receipt?.status !== "accepted") {
         const error = current.error.value || t("jskit.assistant.runtime.delivery.notConfirmed");
         const pending = current.delivery.find(messageId);
@@ -1022,8 +1027,7 @@ function createConversationBinding({ conversationId, endpoint = "", surfaceId =
       acknowledge();
       return { ...receipt, ok: true };
     });
-    return prepare ? current.submitPrepared(captured, { messageId, onAccepted: acknowledge, prepare })
-      : current.send(captured, { messageId, onAccepted: acknowledge });
+    return dispatch();
   }
   const adapter = computed(() => {
     const current = runtime.value;

package/src/client/support/subscribeAssistantConversation.js

@@ -16,6 +16,12 @@ function patchLoadedHistoryPages(pages = [], patch) {
 }
 
 const SNAPSHOT_EVENTS = new Set(["accepted", "settled", "configuration", "phase", "error", "replaced", "goal"]);
+// A connected server may need longer than the normal budget to answer (an
+// overloaded host took 15 s). Abandoning it then discards the server's work and
+// repeats it, so a slow answer only shows a loading notice; it is treated as
+// lost, unsubscribed and retried only after the much longer cap.
+const SUBSCRIPTION_NOTICE_MS = 10_000;
+const SUBSCRIPTION_LOST_MS = 120_000;
 
 function subscribeAssistantConversation({
   socket, conversationId, targetSurfaceId, hostSurfaceId, workspaceSlug,
@@ -44,6 +50,7 @@ function subscribeAssistantConversation({
   // otherwise only the next connect would recover the chat.
   let retryTimer = null;
   let retryDelay = 1_000;
+  let waitingTimer = null;
   const completed = new Map();
   const settledTurns = new Set();
   const pendingReads = new Set();
@@ -187,12 +194,14 @@ function subscribeAssistantConversation({
     if (epoch === null) pending.push(payload);
     else deliver(payload);
   }
-  function clearRetry() {
+  function clearTimers() {
     clearTimeout(retryTimer);
     retryTimer = null;
+    clearTimeout(waitingTimer);
+    waitingTimer = null;
   }
   function subscribe({ preserveHistory = false } = {}) {
-    clearRetry();
+    clearTimers();
     if (disposed || !socket.connected) return;
     const attempt = ++generation;
     epoch = null;
@@ -205,8 +214,12 @@ function subscribeAssistantConversation({
     settledTurns.clear();
     reloadInFlight = null;
     reloadQueued = false;
-    socket.timeout(10_000).emit(ASSISTANT_CONVERSATION_SUBSCRIBE, input, (error, response) => {
+    waitingTimer = setTimeout(() => onError(Object.assign(
+      new Error("Chat is still loading. Waiting for the server; Reload chat to try now."),
+      { code: "assistant_subscription_waiting" })), SUBSCRIPTION_NOTICE_MS);
+    socket.timeout(SUBSCRIPTION_LOST_MS).emit(ASSISTANT_CONVERSATION_SUBSCRIBE, input, (error, response) => {
       if (disposed || attempt !== generation) return;
+      clearTimers();
       if (error || response?.ok !== true) {
         listening = false;
         pending = [];
@@ -232,7 +245,7 @@ function subscribeAssistantConversation({
     });
   }
   function disconnected() {
-    clearRetry();
+    clearTimers();
     generation += 1;
     epoch = null;
     pending = [];
@@ -248,7 +261,7 @@ function subscribeAssistantConversation({
   function release() {
     if (disposed) return;
     disposed = true;
-    clearRetry();
+    clearTimers();
     generation += 1;
     pending = [];
     completed.clear();

package/test/assistantConversationBinding.browser.test.js

@@ -2311,6 +2311,34 @@ test("prepared binding preserves retry identity, newer composer input and inspec
   assert.deepEqual(await f.page.evaluate(() => window.taskClearedFiles), [["original-file"]]);
 });
 
+test("prepared Retry sends an uncertain message again only after the server proves it was never sent", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.provenBinding = window.conversationFixture.acquireConversation({ conversationId: "chat:3", active: false });
+    window.provenReader = window.conversationFixture.acquireConversation({ conversationId: "chat:3" });
+  });
+  await expect.poll(() => f.page.evaluate(() => window.provenReader.runtime.value.available.value)).toBe(true);
+  await f.command("mode", { mode: "uncertain" });
+  const uncertain = await f.page.evaluate(() => window.provenBinding.submitPrepared({ message: "Send me once." },
+    { messageId: "proven-retry", prepare: captured => captured.request }));
+  assert.equal(uncertain.status, "uncertain");
+  assert.equal((await f.sent()).length, 1);
+  // An unknown receipt still never resends.
+  const unknown = await f.page.evaluate(() => window.provenBinding.submitPrepared({ message: "Do not recapture." },
+    { retryMessageId: "proven-retry", prepare: captured => captured.request }));
+  assert.equal(unknown.status, "uncertain");
+  assert.equal((await f.sent()).length, 1);
+  await f.command("mode", { mode: "not-sent" });
+  const retried = await f.page.evaluate(() => window.provenBinding.submitPrepared({ message: "Do not recapture." },
+    { retryMessageId: "proven-retry", prepare: captured => captured.request }));
+  assert.equal(retried.ok, true);
+  const sent = await f.sent();
+  assert.equal(sent.length, 2);
+  assert.equal(sent[1].input.messageId, "proven-retry");
+  assert.equal(sent[1].input.text, "Send me once.");
+  assert.equal(await f.page.evaluate(() => window.provenBinding.runtime.value.delivery.find("proven-retry")?.status ?? "accepted"), "accepted");
+});
+
 test("acceptance settles a voice-retained conversation after its text view retargets without clearing the next composer", options, async t => {
   const f = await fixture(t, 1280, { acceptedDraft: true });
   await f.page.evaluate(() => window.conversationFixture.attachments(true));

package/test/assistantConversationSubscriptions.test.js

@@ -329,45 +329,42 @@ test("slow successful subscriptions warn once with the blocked stage and no conv
   assert.equal(f.fetches.length, 0);
 });
 
-test("the real ten-second subscription deadline releases its late observer and Reload never repeats work", { timeout: 25_000 }, async t => {
+test("a real subscription slower than ten seconds keeps its observer, says it is still loading and delivers the late snapshot", { timeout: 25_000 }, async t => {
   const f = await fixture(t);
   const socket = await f.connect();
   const socketId = socket.id;
   const id = f.ids[0];
-  await f.conversations.get(id).send({ messageId: "survives-timeout", text: "Keep working through a slow snapshot" });
+  await f.conversations.get(id).send({ messageId: "survives-wait", text: "Keep working through a slow snapshot" });
   await until(f.changes, () => f.fetches.length === 1);
   const barrier = f.holdNextRead(id);
   const view = f.view(socket, id);
   await until(f.changes, () => barrier.started);
-  const firstSubscriptionEpoch = f.subscriptionTimings.at(-1).subscriptionEpoch;
-  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. Retrying automatically; Reload chat to try now.");
-  assert.equal(view.errors[0].cause.message, "operation has timed out");
+  const subscriptionEpoch = f.subscriptionTimings.at(-1).subscriptionEpoch;
+  while (!view.errors.length) await once(f.changes, "change", { signal: AbortSignal.timeout(12_000) });
+  assert.equal(view.errors[0].message, "Chat is still loading. Waiting for the server; Reload chat to try now.");
+  assert.equal(view.errors[0].code, "assistant_subscription_waiting");
+  assert.equal(f.active(), 1, "The slow observer stays attached while its snapshot is read");
   assert.equal(socket.id, socketId);
   assert.equal(socket.connected, true);
   assert.equal(view.states.length, 0);
-  assert.equal(f.fetches[0].signal.aborted, false);
-  view.dispose.reload();
-  await until(f.changes, () => view.states.length === 1 && f.active() === 1);
-  assert.equal(view.states[0].conversationLog[0].user.messageId, "survives-timeout");
-  const statesBeforeLateRead = view.states.length;
   barrier.resolve();
-  await until(f.changes, () => f.subscriptionTimings.some(record =>
-    record.subscriptionEpoch === firstSubscriptionEpoch && record.stage === "abandoned"));
-  const abandoned = f.subscriptionTimings.find(record =>
-    record.subscriptionEpoch === firstSubscriptionEpoch && record.stage === "abandoned");
-  assert.equal(abandoned.level, "warn", "A timed-out snapshot remains visible at the production warning level");
-  assert.equal(abandoned.previousStage, "snapshot-read");
-  assert.ok(abandoned.durationMs >= 5_000);
-  assert.equal(view.states.length, statesBeforeLateRead, "The obsolete server read never acknowledges into the recovered view");
-  assert.equal(f.active(), 1, "The late read cannot release the recovered observer");
+  await until(f.changes, () => view.states.length === 1);
+  assert.equal(view.states[0].conversationLog[0].user.messageId, "survives-wait");
+  const records = f.subscriptionTimings.filter(record => record.subscriptionEpoch === subscriptionEpoch);
+  assert.equal(records.some(record => record.stage === "abandoned"), false, "Slow work is never abandoned");
+  const acknowledged = records.find(record => record.stage === "acknowledgement");
+  assert.equal(acknowledged.level, "warn", "A slow snapshot remains visible at the production warning level");
+  assert.equal(acknowledged.previousStage, "snapshot-read");
+  assert.ok(acknowledged.elapsedMs >= 10_000);
+  assert.equal(f.subscriptionTimings.filter(record => record.stage === "authentication").length, 1,
+    "Waiting never sends another subscription");
+  assert.equal(view.errors.length, 1);
+  assert.equal(f.active(), 1);
   assert.equal(f.fetches.length, 1);
   assert.equal(f.fetches[0].signal.aborted, false);
   assert.equal(socket.listeners(ASSISTANT_CONVERSATION_EVENT).length, 1);
-  f.fetches[0].text("Still running after the timed-out observation.");
-  await until(f.changes, () => view.received.some(event => event.text?.includes("timed-out observation")));
+  f.fetches[0].text("Still running after the slow snapshot.");
+  await until(f.changes, () => view.received.some(event => event.text?.includes("slow snapshot")));
   view.dispose();
   await until(f.changes, () => f.active() === 0);
 });
@@ -474,7 +471,7 @@ for (const failure of ["rejection", "timeout"]) {
     const requests = [], states = [], errors = [];
     let reads = 0;
     socket.timeout = timeout => ({ emit(name, input, acknowledge) {
-      assert.equal(timeout, 10_000);
+      assert.equal(timeout, 120_000, "Only a much longer silence counts as a lost answer");
       assert.equal(name, ASSISTANT_CONVERSATION_SUBSCRIBE);
       requests.push({ input, acknowledge });
     } });
@@ -1076,6 +1073,134 @@ test("a retried resubscribe keeps the loaded history its caller preserved", t =>
   subscription();
 });
 
+// Socket.IO's acknowledgement deadline and disconnect handling, on mocked timers.
+function slowServerSocket(t) {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const socket = new EventEmitter();
+  socket.connected = true;
+  const subscribes = [], unsubscribes = [];
+  socket.on(ASSISTANT_CONVERSATION_UNSUBSCRIBE, input => unsubscribes.push(input));
+  socket.timeout = milliseconds => ({ emit(name, input, acknowledge) {
+    let settled = false;
+    const settle = (...args) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      acknowledge(...args);
+    };
+    const timer = setTimeout(() => settle(new Error("operation has timed out")), milliseconds);
+    subscribes.push({ name, input, answer: response => settle(null, response),
+      drop: () => settle(new Error("socket has been disconnected")) });
+  } });
+  function disconnect() {
+    socket.connected = false;
+    socket.emit("disconnect");
+    for (const request of subscribes) request.drop();
+  }
+  return { socket, subscribes, unsubscribes, disconnect };
+}
+const slowState = { id: "chat", conversationLog: [], streaming: { revision: 0, messages: [] } };
+function slowView(socket) {
+  const states = [], errors = [];
+  const subscription = subscribeAssistantConversation({ socket, conversationId: "chat", targetSurfaceId: "home", hostSurfaceId: "home",
+    read: () => slowState, onState: state => states.push(state), onError: error => errors.push(error) });
+  return { states, errors, subscription };
+}
+
+test("a connected subscription keeps waiting for a slow server instead of abandoning its work at ten seconds", t => {
+  // Production: an overloaded daemon answered after 14-15 s; the client gave
+  // up at 10 s, unsubscribed and retried with 10 s again, so the chat never loaded.
+  const { socket, subscribes, unsubscribes } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(9_999);
+  assert.equal(errors.length, 0);
+  t.mock.timers.tick(1);
+  assert.equal(errors.length, 1, "Past the normal budget the user is told the chat is still loading");
+  assert.equal(errors[0].code, "assistant_subscription_waiting");
+  assert.equal(errors[0].message, "Chat is still loading. Waiting for the server; Reload chat to try now.");
+  t.mock.timers.tick(5_000);
+  subscribes[0].answer({ ok: true, streamEpoch: "slow", state: slowState });
+  assert.equal(states.length, 1, "The fifteen-second answer is delivered");
+  assert.equal(subscribes.length, 1, "Waiting never starts another subscription");
+  assert.deepEqual(unsubscribes, [], "Waiting never abandons the server's work");
+  t.mock.timers.tick(300_000);
+  assert.equal(subscribes.length, 1);
+  assert.equal(errors.length, 1);
+  subscription();
+  assert.equal(unsubscribes.length, 1, "Disposal still releases the observer");
+});
+
+test("a subscription answer lost past the two-minute cap still unsubscribes and retries with backoff", t => {
+  const { socket, subscribes, unsubscribes } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(119_999);
+  assert.deepEqual(errors.map(error => error.code), ["assistant_subscription_waiting"]);
+  assert.deepEqual(unsubscribes, []);
+  t.mock.timers.tick(1);
+  assert.deepEqual(unsubscribes, [{ subscriptionId: subscribes[0].input.subscriptionId }]);
+  assert.equal(errors[1].code, "assistant_subscription_transport_failed");
+  assert.equal(errors[1].cause.message, "operation has timed out");
+  t.mock.timers.tick(999);
+  assert.equal(subscribes.length, 1);
+  t.mock.timers.tick(1);
+  assert.equal(subscribes.length, 2, "The lost answer retries after the existing backoff");
+  assert.deepEqual(subscribes[1].input, subscribes[0].input);
+  t.mock.timers.tick(10_000);
+  assert.equal(errors[2].code, "assistant_subscription_waiting", "Each slow attempt says it is still loading");
+  subscribes[1].answer({ ok: true, streamEpoch: "recovered", state: slowState });
+  assert.equal(states.length, 1);
+  assert.equal(unsubscribes.length, 1);
+  subscription();
+});
+
+test("a disconnect while a slow subscription waits resets it and the next connect subscribes again", t => {
+  const { socket, subscribes, unsubscribes, disconnect } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(10_000);
+  assert.equal(errors.length, 1);
+  disconnect();
+  t.mock.timers.tick(300_000);
+  assert.equal(subscribes.length, 1, "A disconnected socket waits for its own reconnect");
+  assert.deepEqual(unsubscribes, [], "There is no connection to unsubscribe on");
+  assert.equal(errors.length, 1, "A disconnect reports no lost answer and no further notice");
+  socket.connected = true;
+  socket.emit("connect");
+  assert.equal(subscribes.length, 2);
+  assert.deepEqual(subscribes[1].input, subscribes[0].input);
+  subscribes[1].answer({ ok: true, streamEpoch: "reconnected", state: slowState });
+  assert.equal(states.length, 1);
+  t.mock.timers.tick(300_000);
+  assert.equal(errors.length, 1);
+  subscription();
+});
+
+test("Reload chat while a slow subscription waits reads history or resubscribes, ignoring the earlier late answer", async t => {
+  const { socket, subscribes, unsubscribes } = slowServerSocket(t);
+  const { states, errors, subscription } = slowView(socket);
+  t.mock.timers.tick(10_000);
+  assert.equal(errors.length, 1);
+  await subscription.reload();
+  assert.equal(states.length, 1, "Reload reads canonical history while the subscription keeps waiting");
+  assert.equal(subscribes.length, 1);
+  subscription.reload({ resubscribe: true });
+  assert.equal(subscribes.length, 2, "A manual resubscribe replaces the waiting attempt by its identity");
+  assert.deepEqual(subscribes[1].input, subscribes[0].input);
+  assert.deepEqual(unsubscribes, []);
+  t.mock.timers.tick(5_000);
+  subscribes[0].answer({ ok: true, streamEpoch: "replaced", state: slowState });
+  assert.equal(states.length, 1, "The replaced attempt's late answer is ignored");
+  assert.equal(errors.length, 1);
+  t.mock.timers.tick(5_000);
+  assert.equal(errors.length, 2, "The replacement attempt has its own loading notice");
+  subscribes[1].answer({ ok: true, streamEpoch: "current", state: slowState });
+  assert.equal(states.length, 2);
+  t.mock.timers.tick(300_000);
+  assert.equal(errors.length, 2);
+  assert.equal(subscribes.length, 2);
+  assert.deepEqual(unsubscribes, []);
+  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();