@jskit-ai/assistant-runtime 0.2.8 → 0.2.9

package/fixtures/canonical-conversation/vite.config.mjs

@@ -110,6 +110,12 @@ export default defineConfig({
           for (const pending of held.splice(0)) pending.respond(pending.receipt);
           return json({ ok: true });
         }
+        if (url.pathname === "/fixture/start-queued-goal") {
+          const state = states.get(input.id);
+          changeGoal(state, state.queuedGoal);
+          state.queuedGoal = null;
+          return json({ ok: true });
+        }
         if (url.pathname === "/fixture/finish") {
           const state = states.get(input.id);
           state.status = "ready";
@@ -145,6 +151,11 @@ export default defineConfig({
           }
           const receipt = command.delivery === "message" ? accept(state, { messageId: input.messageId,
             text: input.objective || (input.action === "resume" ? "Resume the goal." : "Cancel the goal.") }) : null;
+          // The command is accepted behind the running turn; its goal changes later.
+          if (receipt && mode === "queue-goal") {
+            state.queuedGoal = input;
+            return json(receipt);
+          }
           changeGoal(state, input);
           const result = receipt || state.goal || null;
           return json(result, result === null ? 204 : 200);

package/locales/en.json

@@ -74,6 +74,7 @@
         "goal": {
           "budgetsUnsupported": "This conversation does not support goal token budgets.",
           "changeFailed": "Could not change the goal.",
+          "notStarted": "The goal did not start. Check the chat before starting it again.",
           "unavailable": "Goal status is unavailable.",
           "resumeMessage": "Resume the goal.",
           "cancelMessage": "Cancel the goal."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -13,7 +13,7 @@
     "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.6",
+    "@jskit-ai/assistant-core": "0.2.7",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {

package/src/client/composables/useAssistantConversation.js

@@ -110,6 +110,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const loading = ref(true);
   const stopping = ref(false);
   const goalAction = ref("");
+  // An accepted Set or Resume waiting for its goal keeps Pause and Cancel usable.
+  const goalSettling = ref(false);
   const goalTargetCurrent = ref(false);
   const goalError = ref("");
   const goalView = shallowRef(null);
@@ -220,6 +222,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   let goalSegment = null;
   let goalReadController = null;
   let goalReadQueued = false;
+  let goalCommandSequence = 0;
   const readsGoals = computed(() => goalReadEnabled || snapshot.value?.capabilities?.goals === true ||
     [...readers.values()].some(reader => toValue(reader.goal) === true));
   watch(readsGoals, enabled => { if (enabled) void refreshGoal(); });
@@ -377,6 +380,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     for (const pending of pendingMessages.values()) if (!pending.dispatched) pending.controller.abort();
     clearConversationView();
     goalAction.value = "";
+    goalSettling.value = false;
     goalReadQueued = false;
     questions.reset();
   }, { flush: "sync" });
@@ -489,8 +493,10 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     if (deferred) deferredWaits.value += 1;
     try {
       const result = await delivery.send(payload, {
+        // A goal command settles on the server's goal answer, not on its
+        // transcript turn, which can arrive while its goal is still changing.
         messageId, queue, isCurrent: () => current.value, onAccepted,
-        receiptTurns: turns, uncertainOnError: true,
+        receiptTurns: payload.goalRequest ? null : turns, uncertainOnError: true,
         async deliver(submission) {
           pending.started = true;
           let admission = null;
@@ -696,7 +702,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     // it stops and goes straight to the goal operation, even while a message is
     // sending or its receipt is unknown. Set and Resume wait for those.
     const stopping = action === "pause" || action === "cancel";
-    if (!available.value || view?.status !== "available" || goalLoadError.value || goalAction.value || !goalTargetCurrent.value ||
+    if (!available.value || view?.status !== "available" || goalLoadError.value ||
+        goalAction.value && !(stopping && goalSettling.value) || !goalTargetCurrent.value ||
         !["message", "control"].includes(command?.delivery) ||
         !stopping && delivery.state.messages.some(message => message.status === "uncertain")) return false;
     if (input.tokenBudget != null && !target.capabilities.goalBudgets) {
@@ -709,11 +716,16 @@ 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 }) } : {}) };
+    const before = view.goal ? { id: view.goal.id, status: view.goal.status } : null;
+    const sequence = ++goalCommandSequence;
+    let accepted = false;
     goalAction.value = action;
+    goalSettling.value = false;
     goalError.value = "";
     try {
+      let result;
       if (retry || !stopping && command.delivery === "message") {
-        const result = await submitRequest(retry?.payload || {
+        result = await submitRequest(retry?.payload || {
           message: action === "set" ? request.objective
             : t(action === "resume" ? "jskit.assistant.runtime.goal.resumeMessage" : "jskit.assistant.runtime.goal.cancelMessage"),
           goalRequest: request
@@ -724,11 +736,12 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
           }
           return false;
         }
-        return result;
+      } else {
+        result = await api.updateConversationGoal(identity.conversationId,
+          command.delivery === "message" ? { ...request, messageId } : request);
+        if (result?.ok === false) throw new Error(resultError(result) || t("jskit.assistant.runtime.goal.changeFailed"));
       }
-      const result = await api.updateConversationGoal(identity.conversationId,
-        command.delivery === "message" ? { ...request, messageId } : request);
-      if (result?.ok === false) throw new Error(resultError(result) || t("jskit.assistant.runtime.goal.changeFailed"));
+      accepted = true;
       return result;
     } catch (failure) {
       if (current.value) {
@@ -737,13 +750,43 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       }
       return false;
     } finally {
-      if (current.value) {
-        goalAction.value = "";
+      // The command stays Starting, Resuming, Pausing or Cancelling until a goal
+      // read made after the server's answer arrives; until then the control
+      // shows no stale goal or enabled form. An accepted Set or Resume also
+      // waits while its goal waits behind the running turn.
+      if (current.value && goalCommandSequence === sequence) {
         await goalRead;
         await refreshGoal();
+        if (accepted && !stopping) await awaitGoalChange(before, sequence);
         subscription?.reload();
       }
+      if (goalCommandSequence === sequence) {
+        goalAction.value = "";
+        goalSettling.value = false;
+      }
+    }
+  }
+  // An accepted Set or Resume changes the server's goal, now or once the turn
+  // it waits behind has ended. When the conversation stops working without
+  // that change, a fresh read decides and the reason is shown. A later Pause
+  // or Cancel ends the wait.
+  const goalChangedFrom = before => {
+    const goal = goalView.value?.goal;
+    return Boolean(goal) && (goal.id !== before?.id || goal.status !== before?.status);
+  };
+  async function awaitGoalChange(before, sequence) {
+    const settled = () => !current.value || goalCommandSequence !== sequence || goalChangedFrom(before);
+    await subscription?.reload();
+    if (!settled()) goalSettling.value = true;
+    while (!settled() && snapshot.value?.status === "working") {
+      await new Promise(resolve => {
+        const stop = watch([goalView, () => snapshot.value?.status, current, goalAction], () => { stop(); resolve(); });
+      });
     }
+    if (settled()) return;
+    await goalRead;
+    await refreshGoal();
+    if (!settled()) goalError.value = t("jskit.assistant.runtime.goal.notStarted");
   }
   const goalState = computed(() => {
     const view = goalView.value;
@@ -752,7 +795,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const commands = capabilities.goalCommands || {};
     const loading = !goalTargetCurrent.value && !goalLoadError.value;
     const goalAvailable = goalTargetCurrent.value && view?.status === "available" && !goalLoadError.value;
-    const stopPending = Boolean(goalAction.value) || !goalAvailable || !available.value;
+    const stopPending = Boolean(goalAction.value) && !goalSettling.value || !goalAvailable || !available.value;
     return {
       enabled: active.value && Boolean(loading || (view?.status === "available" && !goalLoadError.value) || goalError.value || goalLoadError.value),
       loading,
@@ -762,7 +805,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       tokenBudgetSupported: capabilities.goalBudgets === true,
       goal: goalAvailable && view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
-      pending: stopPending || delivery.state.sending || delivery.state.messages.some(message => message.status === "uncertain"),
+      pending: Boolean(goalAction.value) || stopPending || delivery.state.sending ||
+        delivery.state.messages.some(message => message.status === "uncertain"),
       stopPending,
       error: goalError.value || goalLoadError.value || view?.error || "",
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,

package/test/assistantConversationBinding.browser.test.js

@@ -393,6 +393,117 @@ test("a lost goal receipt uses the same inspection-only ledger and never starts
   assert.equal((await requests()).length, 1, "An undeclared goal command is not exposed or dispatched");
 });
 
+test("Start goal stays Starting… until the goal is read after the server's answer, and no second start is sent", options, async t => {
+  const f = await fixture(t);
+  await f.command("goals", { id: "chat:1", budgets: false, commands: {
+    set: { delivery: "message", interruptsTurn: false }, pause: { delivery: "control", interruptsTurn: true }
+  } });
+  await f.notify("chat:1");
+  const starts = async () => (await f.state()).requests.filter(request => request.suffix === "/goal" && request.method === "POST");
+  await f.primary.getByRole("button", { name: "Set goal", exact: true }).click();
+  const objective = f.page.getByRole("textbox", { name: "Goal objective" });
+  const start = f.page.locator(".assistant-goal__form button[type=submit]");
+  await objective.fill("Finish while the goal read is slow");
+  // Goal reads made after Start wait, as a slow server read does.
+  const reads = Promise.withResolvers();
+  let heldReads = 0;
+  await f.page.route("**/conversations/*/goal", async route => {
+    if (route.request().method() === "GET") {
+      heldReads += 1;
+      await reads.promise;
+    }
+    await route.continue();
+  });
+  await start.click();
+  await expect.poll(async () => (await starts()).length).toBe(1);
+  await expect.poll(() => heldReads).toBeGreaterThan(0);
+  // The server has answered; the control has not yet read the goal it started.
+  await expect(start).toHaveText("Starting…");
+  await expect(start).toBeDisabled();
+  await expect(objective).toHaveValue("Finish while the goal read is slow");
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("set", { objective: "A second start" })), false);
+  reads.resolve();
+  await expect(f.primary.getByRole("button", { name: "Goal running", exact: true })).toHaveAttribute("aria-expanded", "false");
+  assert.equal((await starts()).length, 1, "One Start sends one goal command");
+});
+
+test("a Start accepted behind the running turn stays Starting… until its goal runs, and says so when it never starts", options, async t => {
+  const f = await fixture(t);
+  await f.command("goals", { id: "chat:1", budgets: false, commands: {
+    set: { delivery: "message", interruptsTurn: false }, cancel: { delivery: "control", interruptsTurn: false }
+  } });
+  await f.notify("chat:1");
+  const starts = async () => (await f.state()).requests.filter(request =>
+    request.suffix === "/goal" && request.method === "POST" && request.input.action === "set");
+  const control = name => f.primary.getByRole("button", { name, exact: true });
+  const objective = f.page.getByRole("textbox", { name: "Goal objective" });
+  const start = f.page.locator(".assistant-goal__form button[type=submit]");
+  await f.command("mode", { mode: "queue-goal" });
+  await control("Set goal").click();
+  await objective.fill("Start after the current turn");
+  await start.click();
+  await expect.poll(async () => (await starts()).length).toBe(1);
+  await f.notify("chat:1");
+  // Accepted, but its goal waits behind the running turn.
+  await expect(start).toHaveText("Starting…");
+  await expect(start).toBeDisabled();
+  await expect(objective).toHaveValue("Start after the current turn");
+  await f.page.keyboard.press("Escape");
+  await expect(control("Starting…")).toBeVisible();
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("set", { objective: "A second start" })), false);
+  await f.command("start-queued-goal", { id: "chat:1" });
+  await f.notify("chat:1");
+  await expect(control("Goal running")).toBeVisible();
+  assert.equal((await starts()).length, 1);
+
+  // A Start the conversation finishes without says so and keeps its objective.
+  await control("Goal running").click();
+  await f.page.getByRole("button", { name: "Cancel goal", exact: true }).click();
+  await expect(control("Set goal")).toBeVisible();
+  await objective.fill("Never takes effect");
+  await start.click();
+  await expect.poll(async () => (await starts()).length).toBe(2);
+  await f.notify("chat:1");
+  await expect(start).toBeDisabled();
+  await f.command("finish", { id: "chat:1" });
+  await f.notify("chat:1");
+  await expect(f.page.getByRole("alert").filter({ hasText: "The goal did not start. Check the chat before starting it again." })).toBeVisible();
+  await expect(objective).toHaveValue("Never takes effect");
+  await expect(start).toBeEnabled();
+  assert.equal((await starts()).length, 2);
+});
+
+test("Cancel stays available while a Resume waits behind the running turn and ends that wait", options, async t => {
+  const f = await fixture(t);
+  await f.command("goals", { id: "chat:1", budgets: false, commands: {
+    set: { delivery: "message", interruptsTurn: false }, resume: { delivery: "message", interruptsTurn: false },
+    pause: { delivery: "control", interruptsTurn: false }, cancel: { delivery: "control", interruptsTurn: false }
+  } });
+  await f.notify("chat:1");
+  const control = name => f.primary.getByRole("button", { name, exact: true });
+  const menu = name => f.page.getByRole("button", { name, exact: true });
+  await control("Set goal").click();
+  await f.page.getByRole("textbox", { name: "Goal objective" }).fill("Resume after the current turn");
+  await f.page.locator(".assistant-goal__form button[type=submit]").click();
+  await expect(control("Goal running")).toHaveAttribute("aria-expanded", "false");
+  await control("Goal running").click();
+  await menu("Pause goal").click();
+  await expect(control("Goal paused")).toBeVisible();
+  await f.command("mode", { mode: "queue-goal" });
+  await menu("Resume goal").click();
+  await expect(menu("Resuming…")).toBeDisabled();
+  await f.notify("chat:1");
+  await expect(menu("Cancel goal")).toBeEnabled();
+  await expect(menu("Resuming…")).toBeDisabled();
+  await menu("Cancel goal").click();
+  await expect(control("Set goal")).toBeVisible();
+  await f.command("finish", { id: "chat:1" });
+  await f.notify("chat:1");
+  await expect(f.page.getByRole("alert")).toHaveCount(0);
+  const commands = (await f.state()).requests.filter(request => request.suffix === "/goal" && request.method === "POST");
+  assert.deepEqual(commands.map(request => request.input.action), ["set", "pause", "resume", "cancel"]);
+});
+
 test("a supplied goal view keeps its pinned target and refreshes through the retained binding without polling", options, async t => {
   const f = await fixture(t);
   const goal = { id: "retained-goal", objective: "The plain product objective", status: "paused",
@@ -3372,10 +3483,13 @@ test("a background goal read keeps current pinned controls available and seriali
     await expect(f.page.getByRole("button", { name: "Cancel goal", exact: true })).toBeDisabled();
     assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("cancel")), false);
     releaseCommand();
-    await expect(pause).toBeEnabled();
+    // The answered Pause stays Pausing… until a goal read made after its answer
+    // lands, so the stale goal never offers its controls again.
+    await expect(f.page.getByRole("button", { name: "Pausing…", exact: true })).toBeDisabled();
     assert.equal(commands.length, 1, "Only the actual Pause command was admitted");
     holdRead = false;
     releaseRead();
+    await expect(pause).toBeEnabled();
     await f.page.evaluate(() => window.fixtureBackgroundGoalRead);
     assert.deepEqual(await f.sent(), []);
   } finally {