@jskit-ai/assistant-runtime 0.2.7 → 0.2.8

package/fixtures/canonical-conversation/App.vue

@@ -121,6 +121,8 @@ onMounted(() => {
   window.conversationFixture = {
     socket,
     acquireConversation,
+    // A reader's own visibility, as when an application hides a retained view.
+    activity(value) { return ref(value); },
     releaseFactory() { factoryScope.stop(); },
     target(id) { conversationId.value = id; },
     show(value) { visible.value = value; },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -13,19 +13,19 @@
     "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.5",
+    "@jskit-ai/assistant-core": "0.2.6",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.2",
-    "@jskit-ai/http-web": "0.2.6",
-    "@jskit-ai/kernel": "0.2.2",
-    "@jskit-ai/realtime": "0.2.5",
-    "@jskit-ai/shell-web": "0.2.2",
+    "@jskit-ai/http-runtime": "0.2.3",
+    "@jskit-ai/http-web": "0.2.7",
+    "@jskit-ai/kernel": "0.2.3",
+    "@jskit-ai/realtime": "0.2.6",
+    "@jskit-ai/shell-web": "0.2.3",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.251"
+    "@jskit-ai/database-runtime": "0.1.252"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/composables/useAssistantConversation.js

@@ -136,6 +136,11 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const hasMoreBefore = computed(() => normalizeConversationLogPagination(oldestLoadedPage.value?.pagination).hasMoreBefore);
   const editable = computed(() => active.value && !accessDenied.value);
   const available = computed(() => active.value && !loading.value && !accessDenied.value && Boolean(snapshot.value));
+  // A deferred message keeps the subscription while its view is hidden, so it
+  // is admitted against live state. A failed read leaves that state stale.
+  const deferredWaits = ref(0);
+  const listening = computed(() => active.value || current.value && deferredWaits.value > 0);
+  const admissible = computed(() => listening.value && !loading.value && !accessDenied.value && !error.value && Boolean(snapshot.value));
   const steerable = computed(() => snapshot.value?.status === "working" && snapshot.value?.capabilities?.steering === true);
   const workingPolicy = computed(() => resolveWorkingPolicy(snapshot.value, { deferWhileWorking, admitWhileWorking }));
   const queueing = computed(() => queueWhileSending !== false && (steerable.value || workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking));
@@ -305,7 +310,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       if (denial !== deniedHistoryRevision) {
         throw Object.assign(new Error("Access denied."), { status: 403, messageCode: "assistant.runtime.accessDenied" });
       }
-      return current.value && active.value && subscriptionCurrent();
+      return current.value && listening.value && subscriptionCurrent();
     };
     // A concurrent Load older operation extends the desired span. Retry one
     // refresh in this same read, rather than dropping that newly loaded page.
@@ -354,7 +359,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     }
     return null;
   }
-  watch(active, enabled => {
+  watch(listening, enabled => {
     subscription?.();
     subscription = null;
     historyRevision += 1;
@@ -450,6 +455,9 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   }
   // A deferred message waits only while the working turn cannot take it. It
   // steers as soon as that turn accepts steering, or sends once it is ready.
+  // Its view may be hidden. While loading or after a failed read there is no
+  // current state to admit it against, so the unsent message keeps waiting;
+  // only Stop, Cancel, retirement or lost access end it.
   function waitForAdmission({ controller }) {
     return new Promise(resolve => {
       let stop;
@@ -459,12 +467,13 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         resolve(admission);
       };
       const check = () => {
-        if (controller.signal.aborted || !available.value) finish(false);
+        if (controller.signal.aborted || accessDenied.value) finish(false);
+        else if (!admissible.value) return;
         else if (snapshot.value.status === "ready") finish("send");
         else if (steerable.value) finish("steer");
         else if (snapshot.value.status !== "working") finish(false);
       };
-      stop = watch([available, snapshot, steerable], check, { flush: "sync" });
+      stop = watch([admissible, snapshot, steerable], check, { flush: "sync" });
       controller.signal.addEventListener("abort", check, { once: true });
       check();
     });
@@ -477,6 +486,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const pending = { controller: new AbortController(), started: false, dispatched: false };
     const { controller } = pending;
     pendingMessages.set(messageId, pending);
+    if (deferred) deferredWaits.value += 1;
     try {
       const result = await delivery.send(payload, {
         messageId, queue, isCurrent: () => current.value, onAccepted,
@@ -490,13 +500,12 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
               // Refresh through the same subscription after a queued predecessor;
               // its receipt may have arrived before the working snapshot.
               await subscription?.reload();
-              if (error.value) return false;
-              if (snapshot.value.status === "working" && !steerable.value) {
+              if (snapshot.value?.status === "working" && !steerable.value) {
                 delivery.wait(messageId, t("jskit.assistant.runtime.delivery.waitingForStep"));
               }
               admission = await waitForAdmission(pending);
               delivery.wait(messageId, "");
-              if (!admission || controller.signal.aborted || !available.value ||
+              if (!admission || controller.signal.aborted || !admissible.value ||
                   snapshot.value.status !== (admission === "steer" ? "working" : "ready")) return false;
               if (submission.displayAttachments?.length && snapshot.value.capabilities?.attachments !== true) {
                 return { ok: false, error: t("jskit.assistant.runtime.attachments.noLongerAccepted") };
@@ -566,6 +575,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       return false;
     } finally {
       if (!pending.started && pendingMessages.get(messageId) === pending) pendingMessages.delete(messageId);
+      if (deferred) deferredWaits.value -= 1;
       if (current.value) subscription?.reload();
     }
   }

package/test/assistantConversationBinding.browser.test.js

@@ -1135,6 +1135,85 @@ test("a deferred follow-up explains its wait and steers once the working turn ac
   await expect(f.primary.getByText(/^Pending/)).toHaveCount(0);
 });
 
+// An application keeps a retained view mounted but inactive while another
+// conversation is shown. A message waiting for admission there was never sent:
+// hiding its view must not fail it as "Message could not be sent.", and the
+// person who moved on must not have to return before it is sent.
+test("a deferred message sends while its view is hidden once the session admits it", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.readerActive = window.conversationFixture.activity(true);
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true, active: window.readerActive
+    });
+  });
+  const deferred = () => f.page.evaluate(() => {
+    const runtime = window.deferredBinding.runtime.value;
+    const { id, status, error, waiting } = runtime.delivery.state.messages.find(message => message.text === "Queued while working") || {};
+    return { available: runtime.available.value, status: runtime.snapshot.value?.status, message: { id, status, error, waiting },
+      subscriptions: window.conversationFixture.socket.inspect().active };
+  });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  const { subscriptions } = await deferred();
+  await f.page.evaluate(() => { window.original = window.deferredBinding.runtime.value.send({ message: "Original nonsteerable request" }); });
+  await expect.poll(async () => (await deferred()).status).toBe("working");
+  await f.page.evaluate(() => { window.queued = window.deferredBinding.runtime.value.send({ message: "Queued while working" }); });
+  await expect.poll(async () => (await deferred()).message.waiting).toBe("Waiting for the assistant to finish this step");
+  await f.page.evaluate(() => { window.readerActive.value = false; });
+  await expect.poll(async () => (await deferred()).available).toBe(false);
+  const hidden = await deferred();
+  assert.equal(hidden.message.status, "pending", `hiding the view is not a failed delivery: ${hidden.message.error}`);
+  assert.equal(hidden.subscriptions, subscriptions, "the waiting message keeps its live state");
+  assert.equal((await f.sent()).length, 1, "the working turn still cannot take the message");
+  await f.command("finish", { id: "chat:2" });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(2);
+  const [, followUp] = await f.sent();
+  assert.deepEqual([followUp.input.messageId, followUp.input.text], [hidden.message.id, "Queued while working"]);
+  assert.equal((await f.page.evaluate(() => window.queued)).status, "accepted");
+  const sent = await deferred();
+  assert.equal(sent.available, false, "the message was sent while its view stayed hidden");
+  await expect.poll(async () => (await deferred()).subscriptions, { message: "an empty queue releases the hidden view's subscription" }).toBe(subscriptions - 1);
+  await f.page.evaluate(() => { window.readerActive.value = true; });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  assert.equal((await f.sent()).length, 2, "the queued message is sent once");
+});
+
+// A lost subscription leaves the last snapshot shown with its error while it
+// retries. Its refresh then reads nothing, so that stale error says nothing
+// about the unsent message: it waits for the recovered state and sends once.
+test("a deferred message waits through a failing resubscription instead of failing", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true
+    });
+  });
+  const deferred = () => f.page.evaluate(() => {
+    const runtime = window.deferredBinding.runtime.value;
+    const { id, status, error } = runtime.delivery.state.messages.find(message => message.text === "Sent while reconnecting") || {};
+    return { available: runtime.available.value, error: runtime.error.value, message: { id, status, error } };
+  });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  let failing = true;
+  await f.page.route(url => url.pathname.endsWith("/conversations/chat%3A2"), route => failing && route.request().method() === "GET"
+    ? route.fulfill({ status: 503, contentType: "application/json", body: JSON.stringify({ error: "Conversation temporarily unavailable." }) })
+    : route.continue());
+  await f.page.evaluate(() => window.conversationFixture.socket.reconnect());
+  await expect.poll(async () => (await deferred()).error).toBe("Conversation temporarily unavailable.");
+  assert.equal((await deferred()).available, true, "the last snapshot stays shown");
+  await f.page.evaluate(() => { window.queued = window.deferredBinding.runtime.value.send({ message: "Sent while reconnecting" }); });
+  await expect.poll(async () => (await deferred()).message.status).toBe("pending");
+  const waiting = await deferred();
+  assert.equal((await f.sent()).length, 0, "nothing is admitted against the stale snapshot");
+  failing = false;
+  // The subscription's own retry, not the message, recovers the state.
+  await expect.poll(async () => (await f.sent()).length, { timeout: 15_000 }).toBe(1);
+  const [sent] = await f.sent();
+  assert.deepEqual([sent.input.messageId, sent.input.text], [waiting.message.id, "Sent while reconnecting"]);
+  assert.equal((await f.page.evaluate(() => window.queued)).status, "accepted");
+});
+
 for (const steer of [false, true]) {
   test(`Stop cancels locally queued native ${steer ? "steering" : "startup"} follow-ups`, options, async t => {
     const f = await fixture(t);

package/test/assistantConversationSubscriptions.test.js

@@ -342,6 +342,7 @@ test("a real subscription slower than ten seconds keeps its observer, says it is
   const barrier = f.holdNextRead(id);
   const view = f.view(socket, id);
   await until(f.changes, () => barrier.started);
+  const readStartedAt = performance.now();
   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.");
@@ -350,6 +351,9 @@ test("a real subscription slower than ten seconds keeps its observer, says it is
   assert.equal(socket.id, socketId);
   assert.equal(socket.connected, true);
   assert.equal(view.states.length, 0);
+  // The client's ten-second wait starts before the server's clock does, so the
+  // read is held until the server has also waited ten seconds.
+  await new Promise(resolve => setTimeout(resolve, Math.max(0, 10_001 - (performance.now() - readStartedAt))));
   barrier.resolve();
   await until(f.changes, () => view.states.length === 1);
   assert.equal(view.states[0].conversationLog[0].user.messageId, "survives-wait");