@jskit-ai/assistant-runtime 0.1.232 → 0.1.234

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.232",
+  "version": "0.1.234",
   "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.238",
+    "@jskit-ai/assistant-core": "0.1.240",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.242",
-    "@jskit-ai/http-web": "0.1.90",
-    "@jskit-ai/kernel": "0.1.244",
-    "@jskit-ai/realtime": "0.1.242",
-    "@jskit-ai/shell-web": "0.1.249",
+    "@jskit-ai/http-runtime": "0.1.243",
+    "@jskit-ai/http-web": "0.1.92",
+    "@jskit-ai/kernel": "0.1.245",
+    "@jskit-ai/realtime": "0.1.244",
+    "@jskit-ai/shell-web": "0.1.251",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.244"
+    "@jskit-ai/database-runtime": "0.1.245"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/composables/useAssistantConversation.js

@@ -419,20 +419,23 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     }
     return result;
   }
-  function waitUntilReady({ controller }) {
+  // 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.
+  function waitForAdmission({ controller }) {
     return new Promise(resolve => {
       let stop;
-      const finish = ready => {
+      const finish = admission => {
         stop?.();
         controller.signal.removeEventListener("abort", check);
-        resolve(ready);
+        resolve(admission);
       };
       const check = () => {
         if (controller.signal.aborted || !available.value) finish(false);
-        else if (snapshot.value.status === "ready") finish(true);
+        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], check, { flush: "sync" });
+      stop = watch([available, snapshot, steerable], check, { flush: "sync" });
       controller.signal.addEventListener("abort", check, { once: true });
       check();
     });
@@ -451,19 +454,31 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         receiptTurns: turns, uncertainOnError: true,
         async deliver(submission) {
           pending.started = true;
+          let admission = null;
           try {
             if (controller.signal.aborted || appAdmission && (!available.value || stopping.value || !workingPolicy.value.admitWhileWorking)) return false;
             if (deferred) {
               // Refresh through the same subscription after a queued predecessor;
               // its receipt may have arrived before the working snapshot.
               await subscription?.reload();
-              if (error.value || !await waitUntilReady(pending)) return false;
-              if (controller.signal.aborted || !available.value || snapshot.value.status !== "ready") return false;
+              if (error.value) return false;
+              if (snapshot.value.status === "working" && !steerable.value) {
+                delivery.wait(messageId, "Waiting for the assistant to finish this step");
+              }
+              admission = await waitForAdmission(pending);
+              delivery.wait(messageId, "");
+              if (!admission || controller.signal.aborted || !available.value ||
+                  snapshot.value.status !== (admission === "steer" ? "working" : "ready")) return false;
               if (submission.displayAttachments?.length && snapshot.value.capabilities?.attachments !== true) {
                 return { ok: false, error: "This conversation no longer accepts attachments." };
               }
             }
             let request = prepare ? await prepare(submission, { signal: controller.signal }) : submission.request;
+            if (admission === "steer") {
+              request = { ...request, steer: true };
+              const retained = delivery.find(messageId);
+              if (retained) retained.payload.request = request;
+            }
             if (prepare) {
               if (!current.value || accessDenied.value || controller.signal.aborted || request === false) return false;
               if (!request || typeof request !== "object" || Array.isArray(request)) {

package/test/assistantConversationBinding.browser.test.js

@@ -952,6 +952,32 @@ test("opted-in nonsteerable follow-ups use the original serial queue and dispatc
   assert.equal((await f.sent()).at(-1).input.steer, true);
 });
 
+test("a deferred follow-up explains its wait and steers once the working turn accepts steering", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true
+    });
+    window.conversationFixture.target("chat:2");
+  });
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current()?.identity.conversationId)).toBe("chat:2");
+  await expect(f.input).toBeEnabled();
+  await f.input.fill("Original nonsteerable request");
+  await f.input.press("Enter");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value.status)).toBe("working");
+  await f.input.fill("Follow-up while the turn starts");
+  await f.input.press("Enter");
+  await expect(f.primary.getByText("Pending: Waiting for the assistant to finish this step")).toHaveCount(1);
+  assert.equal((await f.sent()).length, 1, "the follow-up waits while the turn cannot take steering");
+  await f.command("steering", { id: "chat:2", enabled: true });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(2);
+  const [, followUp] = await f.sent();
+  assert.equal(followUp.input.text, "Follow-up while the turn starts");
+  assert.equal(followUp.input.steer, true, "the waiting follow-up reaches the running turn without waiting for it to finish");
+  await expect(f.primary.getByText(/^Pending/)).toHaveCount(0);
+});
+
 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);