@jskit-ai/assistant-runtime 0.2.15 → 0.2.17

package/package.json

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

package/src/client/composables/conversationRuntime.js

@@ -1,6 +1,6 @@
 import { computed, onScopeDispose, ref, shallowRef, toValue, watch } from "vue";
 import { toText } from "@jskit-ai/kernel/shared/support/normalize";
-import { createAssistantMessageDelivery, unmatchedOptimisticMessages } from "@jskit-ai/assistant-core/client/conversation-delivery";
+import { createAssistantMessageDelivery, draftWithRestoredMessage, unmatchedOptimisticMessages } from "@jskit-ai/assistant-core/client/conversation-delivery";
 import { useAssistantQuestions } from "@jskit-ai/assistant-core/client/conversation-questions";
 import { latestAssistantMessageAwaitingUserReply } from "@jskit-ai/assistant-core/shared/conversation";
 import { failureMessage, isAccessDenied, resultError } from "../support/conversationFailures.js";
@@ -124,6 +124,8 @@ function createConversationRuntime({ identity, api, socket, actorKey, placement,
     return Boolean(retry && submitted && (current === submitted || current.startsWith(submitted)));
   });
   let draftSubmissionSequence = 0;
+  // The draft each submitted draft message came from, until its send settles.
+  const submittedDrafts = new Map();
   const error = ref("");
   const loading = ref(true);
   const stopping = ref(false);
@@ -290,6 +292,18 @@ function createConversationRuntime({ identity, api, socket, actorKey, placement,
     questions.reset();
   }, { flush: "sync" });
   onScopeDispose(() => {
+    // A draft message not yet dispatched can no longer be sent: its draft
+    // returns to the saved draft, ahead of any text typed after it. A
+    // dispatched one stays saved and is restored as unconfirmed.
+    const unsent = [...pendingMessages].filter(([messageId, pending]) => !pending.dispatched && submittedDrafts.has(messageId));
+    if (unsent.length && current.value && !accessDenied.value) {
+      for (const [messageId] of unsent.reverse()) {
+        draft.value = draftWithRestoredMessage(submittedDrafts.get(messageId), draft.value);
+        delivery.remove(messageId);
+      }
+      // The scope's watchers have stopped, so the draft is saved here.
+      persistDraft();
+    }
     disposed.value = true;
     subscription();
     stopPlacement();
@@ -349,10 +363,17 @@ function createConversationRuntime({ identity, api, socket, actorKey, placement,
     const sequence = ++draftSubmissionSequence;
     draftRetry.value = null;
     draft.value = retry ? draftAfterAcceptedSubmission(draft.value, draftSnapshot) : "";
-    const result = await send(captured, { messageId: id, onAccepted });
+    submittedDrafts.set(id, draftSnapshot);
+    let result;
+    try { result = await send(captured, { messageId: id, onAccepted }); }
+    finally { submittedDrafts.delete(id); }
     if (!current.value) return false;
     const accepted = result !== false && result?.ok !== false;
-    if (!accepted && kind === "steer" && sequence === draftSubmissionSequence && !draft.value) {
+    const undelivered = !accepted && sequence === draftSubmissionSequence && !draft.value;
+    // No undelivered draft is lost: a failed or unconfirmed message keeps its
+    // words in the chat with Retry, and one never recorded returns to the draft.
+    if (undelivered && kind !== "steer" && !delivery.find(id) && !accessDenied.value) draft.value = draftSnapshot;
+    if (undelivered && kind === "steer") {
       draft.value = draftSnapshot;
       const optimistic = delivery.find(id) || {
         createdAtMs: Date.now(), id, text: String(captured.displayMessage || captured.message || "").trim()

package/src/client/support/subscribeAssistantConversation.js

@@ -251,9 +251,13 @@ function subscribeAssistantConversation({
           retryTimer = setTimeout(() => subscribe({ preserveHistory }), retryDelay);
           retryDelay = Math.min(retryDelay * 2, 30_000);
         }
-        onError(error ? Object.assign(new Error("Chat updates could not reconnect. Retrying automatically; Reload chat to try now.", { cause: error }), {
-          code: "assistant_subscription_transport_failed"
-        }) : Object.assign(new Error(response?.error || "Conversation subscription failed."), {
+        if (error) {
+          onError(Object.assign(new Error("Chat updates could not reconnect. Retrying automatically; Reload chat to try now.", { cause: error }), {
+            code: "assistant_subscription_transport_failed"
+          }));
+          return;
+        }
+        onError(Object.assign(new Error(response?.error || "Conversation subscription failed."), {
           code: response?.code, statusCode: response?.status, params: response?.params,
           ...(response?.error ? { messageCode: response.messageCode, messageParams: response.messageParams }
             : { messageCode: "assistant.runtime.subscription.failed" })

package/test/conversationDraftReturn.test.js

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
+import { effectScope } from "vue";
+import { createConversationRuntime } from "../src/client/composables/conversationRuntime.js";
+
+function memoryStorage() {
+  const values = new Map();
+  return {
+    getItem: key => values.get(key) ?? null,
+    setItem: (key, value) => values.set(key, String(value)),
+    removeItem: key => values.delete(key)
+  };
+}
+
+// A socket that answers each subscription with the conversation's current state.
+function answeringSocket(read) {
+  const socket = {
+    connected: true,
+    on() {},
+    off() {},
+    timeout() { return socket; },
+    emit(name, _input, acknowledge) {
+      if (name === "assistant.conversation.subscribe") acknowledge(null, { ok: true, streamEpoch: "epoch", state: read() });
+    }
+  };
+  return socket;
+}
+
+// One retained conversation over its draft storage. Its sends never answer,
+// so a dispatched message stays in flight.
+async function openConversation(t, { status = "ready", storage = memoryStorage(), deferWhileWorking = false } = {}) {
+  const state = () => ({ id: "chat:1", status, capabilities: { steering: false, attachments: true }, conversationLog: [] });
+  const sent = [];
+  const scope = effectScope();
+  t.after(() => scope.stop());
+  const runtime = scope.run(() => createConversationRuntime({
+    identity: { conversationId: "chat:1", targetSurfaceId: "home", hostSurfaceId: "home", workspaceSlug: "", actorKey: "42" },
+    api: {
+      async readConversation() { return state(); },
+      sendConversationMessage(_id, input) { sent.push(input); return new Promise(() => {}); }
+    },
+    socket: answeringSocket(state),
+    actorKey: "42",
+    placement: { subscribe: () => () => {}, getContext: () => ({}) },
+    readers: new Map([[Symbol("view"), { active: true }]]),
+    retain: () => ({}),
+    queueWhileSending: undefined,
+    deferWhileWorking,
+    admitWhileWorking: false,
+    draftStorage: { storage, key: "chat:1:draft" },
+    application: null,
+    goalReadEnabled: false
+  }));
+  for (let attempt = 0; attempt < 50 && !runtime.available.value; attempt += 1) await delay(1);
+  assert.equal(runtime.available.value, true, "the conversation is ready for a draft");
+  return { runtime, scope, sent, storage };
+}
+
+const saved = storage => JSON.parse(storage.getItem("chat:1:draft") || "{}");
+
+test("a draft whose send ends before any delivery record goes back to the draft", async t => {
+  const { runtime, sent } = await openConversation(t);
+  runtime.draft.value = "First words";
+  void runtime.submitDraft({ message: "First words" });
+  await delay(1);
+  assert.equal(sent.length, 1, "the first message is in flight");
+  // A binding that neither queues nor steers refuses a second send while the first is in flight.
+  runtime.draft.value = "Second words";
+  assert.equal(await runtime.submitDraft({ message: "Second words" }), false);
+  assert.equal(runtime.draft.value, "Second words", "the refused draft is given back");
+  assert.deepEqual(runtime.delivery.state.messages.map(message => message.text), ["First words"]);
+  assert.equal(sent.length, 1);
+});
+
+test("a deferred draft message not yet sent returns to the saved draft when its conversation is released", async t => {
+  const storage = memoryStorage();
+  const first = await openConversation(t, { status: "working", deferWhileWorking: true, storage });
+  first.runtime.draft.value = "Follow-up words";
+  void first.runtime.submitDraft({ message: "Follow-up words" });
+  await delay(1);
+  assert.equal(first.runtime.delivery.state.messages[0]?.status, "pending", "the follow-up waits for the working turn");
+  first.runtime.draft.value = "Typed later";
+  first.scope.stop();
+  assert.equal(first.sent.length, 0, "the waiting follow-up was never dispatched");
+  assert.equal(saved(storage).draft, "Follow-up words\n\nTyped later");
+  assert.deepEqual(saved(storage).messages, []);
+
+  const reopened = await openConversation(t, { storage });
+  assert.equal(reopened.runtime.draft.value, "Follow-up words\n\nTyped later");
+  assert.deepEqual(reopened.runtime.delivery.state.messages, [], "it is not restored as an unconfirmed send");
+  assert.equal(reopened.sent.length, 0);
+});
+
+test("a dispatched draft message stays saved as unconfirmed when its conversation is released", async t => {
+  const storage = memoryStorage();
+  const first = await openConversation(t, { storage });
+  first.runtime.draft.value = "Sent words";
+  void first.runtime.submitDraft({ message: "Sent words" });
+  await delay(1);
+  assert.equal(first.sent.length, 1);
+  first.scope.stop();
+  assert.equal(saved(storage).draft, "");
+
+  const reopened = await openConversation(t, { storage });
+  assert.equal(reopened.runtime.draft.value, "", "a possibly received message never returns to the draft");
+  assert.deepEqual(reopened.runtime.delivery.state.messages.map(message => [message.text, message.status]),
+    [["Sent words", "uncertain"]]);
+});