@jskit-ai/assistant-runtime 0.1.216 → 0.1.218

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.216",
+  "version": "0.1.218",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -12,7 +12,7 @@
     "./server": "./src/server/index.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.223",
+    "@jskit-ai/assistant-core": "0.1.225",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {

package/src/client/composables/useAssistantConversation.js

@@ -84,7 +84,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const error = ref("");
   const loading = ref(true);
   const stopping = ref(false);
-  const goalPending = ref(false);
+  const goalAction = ref("");
   const goalTargetCurrent = ref(false);
   const goalError = ref("");
   const goalView = shallowRef(null);
@@ -115,7 +115,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   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));
-  const canSubmit = computed(() => available.value && (snapshot.value.status === "ready" || steerable.value || (workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking) && snapshot.value.status === "working") &&
+  const canSubmit = computed(() => available.value && !stopping.value && (snapshot.value.status === "ready" || steerable.value || (workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking) && snapshot.value.status === "working") &&
     (queueWhileSending !== false || !delivery.state.sending) &&
     !delivery.state.messages.some(message => message.status === "uncertain" &&
       (snapshot.value.status !== "ready" || !message.payload || text(message.payload.draft ?? message.payload.message) === text(draft))));
@@ -221,6 +221,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       // Keep the open goal menu while its first native identity arrives. The
       // pending read disables commands until it supplies the new exact target.
       goalTargetCurrent.value = false;
+      goalLoadError.value = "";
       goalReadController?.abort();
     }
     if (readsGoals.value && (initial || goalChanged || state.segmentId !== goalSegment)) void refreshGoal();
@@ -338,7 +339,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     draftAttachments.value = [];
     draftRetry.value = null;
     goalError.value = "";
-    goalPending.value = false;
+    goalAction.value = "";
     goalView.value = null;
     goalLoadError.value = "";
     goalReadQueued = false;
@@ -441,7 +442,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     if (pendingMessages.has(messageId)) return false;
     // Register before the original serial tail so Stop/retirement also reaches
     // a local follower whose deliver callback has not started yet.
-    const pending = { controller: new AbortController(), started: false, dispatched: false, deferred, appAdmission };
+    const pending = { controller: new AbortController(), started: false, dispatched: false };
     const { controller } = pending;
     pendingMessages.set(messageId, pending);
     try {
@@ -592,7 +593,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const view = goalView.value;
     const target = view?.target;
     const command = target?.capabilities?.goalCommands?.[action];
-    if (!available.value || view?.status !== "available" || goalLoadError.value || goalPending.value || !goalTargetCurrent.value ||
+    if (!available.value || view?.status !== "available" || goalLoadError.value || goalAction.value || !goalTargetCurrent.value ||
         !["message", "control"].includes(command?.delivery) ||
         delivery.state.messages.some(message => message.status === "uncertain")) return false;
     if (input.tokenBudget != null && !target.capabilities.goalBudgets) {
@@ -605,7 +606,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       expectedGoalId: view.goal?.id || null,
       ...(action === "set" ? { objective: String(input.objective || "").trim(),
         ...(input.tokenBudget == null ? {} : { tokenBudget: input.tokenBudget }) } : {}) };
-    goalPending.value = true;
+    goalAction.value = action;
     goalError.value = "";
     try {
       if (retry || command.delivery === "message") {
@@ -630,7 +631,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       return false;
     } finally {
       if (current.value) {
-        goalPending.value = false;
+        goalAction.value = "";
         await goalRead;
         await refreshGoal();
         subscription?.reload();
@@ -642,14 +643,19 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     if (!readsGoals.value) return null;
     const capabilities = view?.target?.capabilities || {};
     const commands = capabilities.goalCommands || {};
+    const loading = !goalTargetCurrent.value && !goalLoadError.value;
+    const goalAvailable = goalTargetCurrent.value && view?.status === "available" && !goalLoadError.value;
     return {
-      enabled: active.value && Boolean((view?.status === "available" && !goalLoadError.value) || goalError.value),
+      enabled: active.value && Boolean(loading || (view?.status === "available" && !goalLoadError.value) || goalError.value || goalLoadError.value),
+      loading,
+      available: Boolean(goalAvailable),
+      action: goalAction.value,
       tokenBudgetSupported: capabilities.goalBudgets === true,
-      goal: view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
+      goal: goalAvailable && view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
-      pending: goalPending.value || !goalTargetCurrent.value || !available.value || delivery.state.sending ||
+      pending: Boolean(goalAction.value) || !goalAvailable || !available.value || delivery.state.sending ||
         delivery.state.messages.some(message => message.status === "uncertain"),
-      error: goalError.value,
+      error: goalError.value || goalLoadError.value,
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,
       cancelInterruptsTurn: commands.cancel?.interruptsTurn === true,
       ...Object.fromEntries(["set", "resume", "pause", "cancel"].filter(action =>
@@ -660,7 +666,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     if (!editable.value || stopping.value) return false;
     stopping.value = true;
     for (const pending of pendingMessages.values()) {
-      if ((pending.deferred || pending.appAdmission) && !pending.dispatched) pending.controller.abort();
+      if (!pending.dispatched) pending.controller.abort();
     }
     try { return await api.cancelConversation(identity.conversationId); }
     catch (failure) { receiveError(failure); return false; }

package/test/assistantConversationBinding.browser.test.js

@@ -295,6 +295,12 @@ test("a supplied goal view keeps its pinned target and refreshes through the ret
   failedRead = true;
   await f.page.evaluate(() => window.conversationFixture.current().refreshGoal());
   await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalLoadError.value)).toBe("Goal status is unavailable.");
+  await expect(f.primary.getByRole("button", { name: "Goal unavailable", exact: true })).toBeVisible();
+  assert.deepEqual(await f.page.evaluate(() => {
+    const state = window.conversationFixture.current().goalState.value;
+    return { available: state.available, goal: state.goal, pending: state.pending };
+  }), { available: false, goal: null, pending: true });
+  await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
   assert.equal(await f.page.evaluate(() => window.conversationFixture.current().error.value), "",
     "Passive goal failure does not enter conversation or app-wide request recovery");
   await expect(f.input).toBeEnabled();
@@ -877,6 +883,41 @@ test("opted-in nonsteerable follow-ups use the original serial queue and dispatc
   assert.equal((await f.sent()).at(-1).input.steer, true);
 });
 
+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);
+    await f.command("steering", { id: "chat:1", enabled: true });
+    await f.command("mode", { mode: "hold" });
+    await f.page.evaluate(() => {
+      window.firstNative = window.conversationFixture.current().send({ message: "First held instruction" });
+    });
+    await expect.poll(async () => (await f.state()).held).toBe(1);
+    await f.command("question", { id: "chat:1", text: "Starting native work", pending: true });
+    await f.notify("chat:1");
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().steerable.value)).toBe(true);
+    await f.page.evaluate(steer => {
+      window.queuedNative = window.conversationFixture.current().send({ message: "Queued native follow-up",
+        request: { text: "Queued native follow-up", steer } });
+    }, steer);
+    assert.equal((await f.sent()).length, 1);
+    const stopGate = Promise.withResolvers();
+    t.after(() => stopGate.resolve());
+    await f.page.route("**/cancel", async route => { await stopGate.promise; await route.continue(); });
+    await f.page.evaluate(() => { window.stoppingNative = window.conversationFixture.current().cancel(); });
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().stopping.value)).toBe(true);
+    const canSendDuringStop = await f.page.evaluate(() => window.conversationFixture.current().canSubmit.value);
+    stopGate.resolve();
+    await f.page.evaluate(() => window.stoppingNative);
+    await f.command("mode", { mode: "accepted" });
+    await f.command("accept");
+    await f.page.evaluate(() => window.firstNative);
+    const queuedResult = await f.page.evaluate(() => window.queuedNative);
+    assert.equal((await f.sent()).length, 1, "Stop must prevent a local follower from dispatching after the first receipt");
+    assert.equal(queuedResult, false);
+    assert.equal(canSendDuringStop, false, "new sends wait for Stop confirmation");
+  });
+}
+
 for (const action of ["stop", "actor", "denied"]) {
   test(`opted-in local followers cannot dispatch after ${action}`, options, async t => {
     const f = await fixture(t);
@@ -2912,6 +2953,11 @@ test("changing the observed native segment blocks cached goal controls until the
     await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value.segmentId)).toBe("replacement-native-observation");
     await expect.poll(() => Boolean(releaseRead)).toBe(true);
     assert.equal(await f.page.evaluate(() => window.conversationFixture.current().goalState.value.pending), true);
+    assert.equal(await f.page.evaluate(() => window.conversationFixture.current().goalState.value.loading), true);
+    assert.equal(await f.page.evaluate(() => window.conversationFixture.current().goalState.value.goal), null);
+    await expect(f.primary.getByRole("button", { name: "Loading goal…", exact: true })).toBeVisible();
+    await expect(f.page.getByRole("button", { name: "Pause goal", exact: true })).toHaveCount(0);
+    await expect(f.page.getByRole("button", { name: "Resuming…", exact: true })).toHaveCount(0);
     assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("pause")), false);
     assert.deepEqual(commands, [], "A previous observation cannot authorize a command for the replacement thread");
     view.goal.id = "replacement-goal";
@@ -3011,3 +3057,31 @@ for (const width of [1280, 390]) test(`ten real messages per history load across
   await expect(f.primary.getByRole("button", { name: "Load older messages", exact: true })).toHaveCount(0);
   assert.deepEqual(await f.sent(), []);
 });
+
+
+test("initial goal loading shows no goal commands until the empty goal is confirmed", options, async t => {
+  const f = await fixture(t);
+  const waiting = Promise.withResolvers();
+  const entered = Promise.withResolvers();
+  await f.page.route("**/conversations/*/goal", async route => {
+    entered.resolve();
+    await waiting.promise;
+    return route.fulfill({ json: { status: "available", goal: null, target: { segmentId: "empty-goal",
+      capabilities: { goals: true, goalBudgets: false, goalCommands: {
+        set: { delivery: "message", interruptsTurn: false }, resume: { delivery: "message", interruptsTurn: false }
+      } } } } });
+  });
+  try {
+    await f.page.evaluate(() => window.conversationFixture.eventReaders([{ id: "goal-reader", goal: true }]));
+    await entered.promise;
+    const loading = f.primary.getByRole("button", { name: "Loading goal…", exact: true });
+    await expect(loading).toBeVisible();
+    await loading.click();
+    await expect(f.page.getByRole("button", { name: "Start goal", exact: true })).toHaveCount(0);
+    await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
+    waiting.resolve();
+    await expect(f.primary.getByRole("button", { name: "Set goal", exact: true })).toBeVisible();
+    await expect(f.page.getByRole("button", { name: "Start goal", exact: true })).toBeVisible();
+    await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
+  } finally { waiting.resolve(); }
+});