@jskit-ai/assistant-core 0.2.10 → 0.2.11

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.10",
-    "@jskit-ai/http-runtime": "0.2.4",
-    "@jskit-ai/kernel": "0.2.4",
+    "@jskit-ai/assistant-core": "0.2.11",
+    "@jskit-ai/http-runtime": "0.2.5",
+    "@jskit-ai/kernel": "0.2.5",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.5",
-    "@jskit-ai/connectors-catalog": "0.2.5"
+    "@jskit-ai/connectors-core": "0.2.6",
+    "@jskit-ai/connectors-catalog": "0.2.6"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -51,8 +51,8 @@
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
     "@jskit-ai/agent": "0.1.0",
-    "@jskit-ai/resource-core": "0.1.195",
-    "@jskit-ai/resource-crud-core": "0.1.195",
+    "@jskit-ai/resource-core": "0.1.196",
+    "@jskit-ai/resource-crud-core": "0.1.196",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.152",
@@ -61,8 +61,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.4",
-    "@jskit-ai/kernel": "0.2.4",
+    "@jskit-ai/http-runtime": "0.2.5",
+    "@jskit-ai/kernel": "0.2.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/server/conversation/continuity.js

@@ -4,6 +4,7 @@ import { isCompletedEnvelopeTurn } from "./transcript.js";
 import { ignorePromptRejection, ignorePromptSending } from "./nativeCommandCallbacks.js";
 
 // A final answer keeps its identity when an application edits its visible text.
+// A turn's later replies repeat it here; distinctMessages tells them apart.
 export function conversationMessageIdentity(turnId, message) {
   return `${turnId}/${message.role}/${["user", "assistant", "system"].includes(message.role)
     ? "" : message.messageId || message.at}`;
@@ -16,6 +17,24 @@ export function conversationMessageVersion(message, { includeData = false } = {}
   })).digest("hex");
 }
 
+/**
+ * Native continuations add later replies to a turn, and those repeat its identity. The first keeps
+ * it, because saved cursors and an edited final answer use it, and each later one adds its own id.
+ * The original version saved for a repeated identity names only the last reply written, so it is dropped.
+ * @param {object[]} messages
+ * @returns {object[]}
+ */
+function distinctMessages(messages) {
+  const repeats = Map.groupBy(messages, message => message.id);
+  return messages.map(message => {
+    const repeated = repeats.get(message.id);
+    if (repeated.length === 1) return message;
+    const { originalVersion: _lastWritten, ...distinct } = message;
+    const position = repeated.indexOf(message);
+    return position ? { ...distinct, id: `${message.id}${message.messageId || position + 1}` } : distinct;
+  });
+}
+
 // A changeover whose owner keeps no delivery log.
 function logNothing() {}
 
@@ -70,7 +89,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
       lastEngine: engineId,
       engines: {
         [engineId]: {
-          seen: Object.fromEntries(messages.map((message) => [message.id, message.originalVersion || message.version]))
+          seen: Object.fromEntries(distinctMessages(messages).map((message) => [message.id, message.originalVersion || message.version]))
         }
       }
     };
@@ -81,7 +100,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
     const seen = value.engines[engineId].seen;
     // New replies from the last engine are already in that native conversation.
     // Preserve old fingerprints: an edited bubble still needs to be delivered.
-    for (const message of messages) {
+    for (const message of distinctMessages(messages)) {
       if (message.engineId === engineId && !Object.hasOwn(seen, message.id)) {
         seen[message.id] = message.originalVersion || message.version;
       }
@@ -146,16 +165,17 @@ export function createConversationChangeover({ state, transcript, agent, identit
       code: unconfirmedCode, messageId, threadId, error: unconfirmedMessage };
   }
 
-  async function send({ engineId, messages, input, turnMetadata, completedEnvelope = false, excludedMessageIds = [], inspectOnly = false }) {
+  async function send({ engineId, messages: written, input, turnMetadata, completedEnvelope = false, excludedMessageIds = [], inspectOnly = false }) {
     if (typeof completedEnvelope !== "boolean" || !Array.isArray(excludedMessageIds) ||
         excludedMessageIds.some(id => typeof id !== "string" || !id.trim() || id.length > 128) ||
         new Set(excludedMessageIds).size !== excludedMessageIds.length || excludedMessageIds.length && !completedEnvelope) {
       throw new TypeError("Native history exclusions require a tracked completed envelope and exact message IDs.");
     }
     const excluded = new Set(excludedMessageIds);
-    const value = await readState({ engineId, messages });
+    const value = await readState({ engineId, messages: written });
     const binding = value.engines[engineId] ||= { seen: {} };
-    rememberReplies(value, engineId, messages);
+    rememberReplies(value, engineId, written);
+    const messages = distinctMessages(written);
     const persist = () => state.write(value);
     async function markDelivered(seen) {
       const replacement = value.replacement;
@@ -383,7 +403,7 @@ function writtenMessages(history, native = false) {
 export const conversationNativeMessages = history => writtenMessages(history, true);
 
 export function conversationHistoryVersions(history) {
-  return Object.fromEntries(writtenMessages(history).map(message => [message.id, message.version]));
+  return Object.fromEntries(distinctMessages(writtenMessages(history)).map(message => [message.id, message.version]));
 }
 
 export function conversationRequestText({ text, origin, data }) {

package/test/codexTurn.test.js

@@ -3685,6 +3685,160 @@ test("native history budget resolves only for new catch-up and preserves the ret
   assert.equal(sent[2].message, "Just these words");
 });
 
+// One saved turn that native continuations can add replies to, delivered through a changeover.
+async function continuedConversation() {
+  const { createConversationChangeover, conversationNativeMessages, conversationHistoryVersions } = await import("../src/server/conversation/continuity.js");
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  const { turnId } = await transcript.writeConversationUserMessage("chat", { messageId: "request", text: "Write a report",
+    at: "2026-10-01T01:00:00.000Z", turnMetadata: { runtime: { engine: "claude" } } });
+  let saved = { lastEngine: "claude", engines: { claude: { seen: {} } } };
+  let sends = 0;
+  let prompt = "";
+  const changeover = createConversationChangeover({
+    state: { async read() { return structuredClone(saved); }, async write(next) { saved = structuredClone(next); } },
+    transcript: { async hasMessage() { return false; } },
+    agent: { async sendMessage(input) { prompt = input.message; return { ok: true, delivered: true }; } }
+  });
+  const turns = () => transcript.readConversationLog("chat");
+  let written = 0;
+  return {
+    transcript, turnId, turns,
+    reply: (messageId, text) => transcript.writeConversationAssistantMessage("chat", { messageId, text, turnId,
+      at: `2026-10-01T01:00:0${++written}.000Z` }),
+    edit: (messageId, text) => storage.write("chat", async tx => {
+      const message = (await tx.readTurn(turnId)).messages.find(row => row.messageId === messageId);
+      await tx.appendMessage(turnId, { ...message, text });
+    }),
+    history: async () => conversationNativeMessages(await turns()),
+    versions: async () => conversationHistoryVersions(await turns()),
+    save(value) { saved = value; },
+    seen: (engineId = "claude") => saved.engines[engineId].seen,
+    async send(engineId = "claude", messages) {
+      await changeover.send({ engineId, messages: messages || conversationNativeMessages(await turns()),
+        input: { messageId: `follow-up-${++sends}`, message: "Next" } });
+      return prompt;
+    }
+  };
+}
+
+// What a changeover preamble carried: each message's id, text and correction mark, and the removals.
+function carriedHistory(prompt) {
+  const { messages, removedMessageIds } = JSON.parse(prompt.split("\n").find(line => line.startsWith('{"messages"')));
+  return { messages: messages.map(message => [message.messageId, message.text, message.corrected]), removedMessageIds };
+}
+
+test("replies that share a turn are each remembered, so later messages carry no changeover preamble", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  assert.equal(await f.send(), "Next");
+  assert.equal(await f.send(), "Next");
+  // A native continuation after that delivery is already in the engine's own conversation.
+  await f.reply("late", "The stale helper stopped.");
+  assert.equal(await f.send(), "Next");
+  assert.deepEqual(f.seen(), await f.versions());
+  assert.deepEqual(Object.keys(f.seen()), ["000001/user/", "000001/assistant/", "000001/assistant/report", "000001/assistant/late"]);
+});
+
+test("replies without message ids keep separate identities in one turn", async () => {
+  const f = await continuedConversation();
+  await f.transcript.writeConversationAssistantMessage("chat", { text: "First", turnId: f.turnId, at: "2026-10-01T01:00:01.000Z" });
+  await f.transcript.writeConversationAssistantMessage("chat", { text: "Second", turnId: f.turnId, at: "2026-10-01T01:00:02.000Z" });
+  assert.equal(await f.send(), "Next");
+  assert.equal(await f.send(), "Next");
+  assert.deepEqual(Object.keys(f.seen()), ["000001/user/", "000001/assistant/", "000001/assistant/2"]);
+});
+
+test("a corrected reply in a shared turn is delivered alone, and merged replies are reported removed", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  assert.equal(await f.send(), "Next");
+  await f.edit("report", "The corrected report.");
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["report", "The corrected report.", true]], removedMessageIds: [] });
+  assert.equal(await f.send(), "Next");
+  await f.edit("interim", "The corrected status.");
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["interim", "The corrected status.", true]], removedMessageIds: [] });
+  assert.equal(await f.send(), "Next");
+  // An application's edit replaces every reply in the turn and keeps the first one's identity.
+  await f.transcript.upsertConversationAssistantMessage("chat", { turnId: f.turnId, text: "One merged answer." });
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["interim", "One merged answer.", true]], removedMessageIds: ["000001/assistant/report"] });
+  assert.equal(await f.send(), "Next");
+});
+
+test("a cursor saved while replies shared one identity delivers one correction, then none", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  const [user, first, last] = await f.history();
+  f.save({ lastEngine: "claude", engines: { claude: { seen: { [user.id]: user.version, [first.id]: last.version } } } });
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["interim", "The query is still running.", true]], removedMessageIds: [] });
+  assert.deepEqual(f.seen(), await f.versions());
+  assert.equal(await f.send(), "Next");
+});
+
+test("a cursor saved with a turn's first reply is already current", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  const [user, first] = await f.history();
+  f.save({ lastEngine: "claude", engines: { claude: { seen: { [user.id]: user.version, [first.id]: first.version } } } });
+  assert.equal(await f.send(), "Next");
+  assert.deepEqual(f.seen(), await f.versions());
+  assert.equal(await f.send(), "Next");
+});
+
+test("a cursor saved while replies shared one identity delivers a returning engine's turn once", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  const [user, first, last] = await f.history();
+  await f.reply("late", "The stale helper stopped.");
+  f.save({ lastEngine: "claude", engines: { codex: { seen: { [user.id]: user.version, [first.id]: last.version } } } });
+  assert.deepEqual(carriedHistory(await f.send("codex")), { messages: [
+    ["interim", "The query is still running.", true], ["report", "The report.", undefined],
+    ["late", "The stale helper stopped.", undefined]], removedMessageIds: [] });
+  assert.deepEqual(f.seen("codex"), await f.versions());
+  assert.equal(await f.send("codex"), "Next");
+});
+
+test("a cursor saved while replies shared one identity keeps real corrections", async () => {
+  const shared = await continuedConversation();
+  await shared.reply("interim", "The query is still running.");
+  await shared.reply("report", "The report.");
+  const [user, first] = await shared.history();
+  shared.save({ lastEngine: "claude", engines: { claude: { seen: { [user.id]: user.version, [first.id]: "before-the-edit" } } } });
+  assert.deepEqual(carriedHistory(await shared.send()),
+    { messages: [["interim", "The query is still running.", true]], removedMessageIds: [] });
+  assert.equal(await shared.send(), "Next");
+
+  const merged = await continuedConversation();
+  await merged.reply("interim", "The query is still running.");
+  await merged.reply("report", "The report.");
+  const [mergedUser, , reportBeforeEdit] = await merged.history();
+  merged.save({ lastEngine: "claude", engines: { claude: { seen: { [mergedUser.id]: mergedUser.version,
+    [reportBeforeEdit.id]: reportBeforeEdit.version } } } });
+  await merged.transcript.upsertConversationAssistantMessage("chat", { turnId: merged.turnId, text: "One merged answer." });
+  assert.deepEqual(carriedHistory(await merged.send()),
+    { messages: [["interim", "One merged answer.", true]], removedMessageIds: [] });
+  assert.equal(await merged.send(), "Next");
+});
+
+test("a host's history may repeat a turn's identity and its last written original version", async () => {
+  const f = await continuedConversation();
+  const reply = { id: "000001/assistant/", role: "assistant", engineId: "claude", originalVersion: "report-version" };
+  const messages = [{ ...reply, messageId: "interim", text: "Running.", version: "interim-version" },
+    { ...reply, messageId: "report", text: "The report.", version: "report-version" }];
+  assert.equal(await f.send("claude", messages), "Next");
+  assert.deepEqual(f.seen(), { "000001/assistant/": "interim-version", "000001/assistant/report": "report-version" });
+  assert.equal(await f.send("claude", messages), "Next");
+});
+
 test("native history budget rejects unavailable dynamic limits before pending delivery", async () => {
   const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
   for (const budget of [0, -1, NaN, Infinity, "4096", undefined]) {