@jskit-ai/assistant-core 0.2.10 → 0.2.12

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.12",
+    "@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/fixtures/responsive-assistant/DeliveryFixture.vue

@@ -5,6 +5,7 @@ import { createAssistantMessageDelivery } from "../../src/client/conversation/me
 
 const recoveryFixture = new URLSearchParams(location.search).has("recovery");
 const acceptedFixture = new URLSearchParams(location.search).has("accepted-history");
+const taskFixture = new URLSearchParams(location.search).has("task");
 const draft = ref("");
 const turns = ref([]);
 const requests = ref([]);
@@ -63,7 +64,10 @@ if (acceptedFixture) {
 }
 const adapter = reactive({
   delivery, attachments,
-  conversation: { cancellableDelivery: recoveryFixture, turns, visible: true, scrollKey: "delivery", welcomeMessage: "Start a conversation." },
+  conversation: {
+    cancellableDelivery: recoveryFixture, turns, visible: true, scrollKey: "delivery", welcomeMessage: "Start a conversation.",
+    variant: taskFixture ? "task" : "main"
+  },
   composer: { draft, canSend: true, submitOnEnter: true, queueWhileSending },
   actions: {
     setDraft(value) { draft.value = value; },

package/fixtures/responsive-assistant/main.js

@@ -9,6 +9,7 @@ import ConversationFixture from "./ConversationFixture.vue";
 import ProgressFixture from "./ProgressFixture.vue";
 import DeliveryFixture from "./DeliveryFixture.vue";
 
+const query = new URLSearchParams(location.search);
 const vuetify = createVuetify({
   components,
   directives,
@@ -18,11 +19,10 @@ const vuetify = createVuetify({
     sets: { mdi }
   },
   theme: {
-    defaultTheme: "light"
+    defaultTheme: query.has("dark") ? "dark" : "light"
   }
 });
 
-const query = new URLSearchParams(location.search);
 createApp(query.has("delivery") ? DeliveryFixture : query.has("progress") ? ProgressFixture : query.has("conversation") ? ConversationFixture : App)
   .use(vuetify)
   .mount("#app");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "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/client/conversation/AssistantTranscript.css

@@ -248,8 +248,8 @@
 }
 
 .assistant-transcript--task .assistant-transcript__message--user {
-  background: #eee8f8;
-  color: #2d2440;
+  background: rgba(126, 87, 194, 0.16);
+  color: rgb(var(--v-theme-on-surface));
 }
 
 .assistant-transcript__thinking {
@@ -325,13 +325,13 @@
 }
 
 .assistant-transcript__message-header time {
-  color: #6d7888;
+  color: rgba(var(--v-theme-on-surface), var(--v-medium-emphasis-opacity));
   font-weight: 650;
 }
 
 .assistant-transcript__message-footer {
   align-items: center;
-  color: #9aa6b6;
+  color: rgba(var(--v-theme-on-surface), var(--v-medium-emphasis-opacity));
   display: flex;
   font-size: 0.88rem;
   font-weight: 500;

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]) {

package/test/transcriptTheme.browser.test.js

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { chromium, expect } from "@playwright/test";
+import { createChromiumLaunchOptions, startViteFixture, stopProcess } from "../../../tooling/testUtils/browserFixture.mjs";
+
+// An element's text colour, the theme values it should come from, and its WCAG contrast over what is painted under
+// it: each translucent background is laid over the next one out, down to the first opaque one (white when none is).
+// Runs in the page.
+function readText(element) {
+  const channels = (value) => {
+    const [red, green, blue, alpha = 1] = value.match(/[\d.]+/gu).map(Number);
+    return { red, green, blue, alpha };
+  };
+  const over = (top, under) => ({
+    red: top.red * top.alpha + under.red * (1 - top.alpha),
+    green: top.green * top.alpha + under.green * (1 - top.alpha),
+    blue: top.blue * top.alpha + under.blue * (1 - top.alpha),
+    alpha: 1
+  });
+  const luminance = ({ red, green, blue }) => {
+    const [r, g, b] = [red, green, blue].map((channel) => {
+      const value = channel / 255;
+      return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+    });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  };
+  const layers = [];
+  for (let node = element; node; node = node.parentElement) {
+    const background = channels(getComputedStyle(node).backgroundColor);
+    if (background.alpha > 0) layers.push(background);
+    if (background.alpha === 1) break;
+  }
+  const backdrop = layers.reverse().reduce((under, layer) => over(layer, under), { red: 255, green: 255, blue: 255, alpha: 1 });
+  const style = getComputedStyle(element);
+  const color = channels(style.color);
+  const [lighter, darker] = [luminance(over(color, backdrop)), luminance(backdrop)].sort((a, b) => b - a);
+  return {
+    color: [color.red, color.green, color.blue, color.alpha],
+    onSurface: style.getPropertyValue("--v-theme-on-surface").split(",").map(Number),
+    mediumEmphasis: Number(style.getPropertyValue("--v-medium-emphasis-opacity")),
+    contrast: (lighter + 0.05) / (darker + 0.05)
+  };
+}
+
+test("the task transcript's user bubble, header time and footer follow the light and dark themes", {
+  skip: process.env.JSKIT_ASSISTANT_CORE_BROWSER_INTEGRATION !== "1", timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: fileURLToPath(new URL("../fixtures/responsive-assistant", import.meta.url)) });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const theme of ["light", "dark"]) {
+      const page = await browser.newPage({ viewport: { width: 800, height: 900 } });
+      await page.goto(`${vite.baseURL}/?delivery=1&recovery=1&task=1${theme === "dark" ? "&dark=1" : ""}`);
+      await expect(page.locator(".v-application")).toHaveClass(new RegExp(`v-theme--${theme}`, "u"));
+      const bubble = page.locator(".assistant-transcript--task .assistant-transcript__message--user").filter({ hasText: "Question one" });
+      await expect(bubble).toBeVisible();
+      assert.equal(await bubble.evaluate((element) => getComputedStyle(element).backgroundColor), "rgba(126, 87, 194, 0.16)");
+      // The transcript's own headers carry no time, so the check places one where an application's header would.
+      const header = page.locator(".assistant-transcript__turn .assistant-transcript__message-header").first();
+      await header.evaluate((element) => {
+        const time = document.createElement("time");
+        for (const { name } of element.attributes) {
+          if (name.startsWith("data-v-")) time.setAttribute(name, "");
+        }
+        time.textContent = "06:02";
+        element.append(time);
+      });
+      const samples = {
+        "user bubble": [bubble.locator(".assistant-transcript__user-content"), 1],
+        "user footer": [bubble.locator(".assistant-transcript__message-footer time"), "medium"],
+        "assistant footer": [page.locator(".assistant-transcript__message-footer--assistant time").first(), "medium"],
+        "header time": [header.locator("time"), "medium"]
+      };
+      for (const [name, [locator, alpha]] of Object.entries(samples)) {
+        const text = await locator.evaluate(readText);
+        assert.deepEqual(text.color.slice(0, 3), text.onSurface, `${theme} ${name}: the colour is the theme's on-surface`);
+        assert.equal(text.color[3], alpha === "medium" ? text.mediumEmphasis : alpha, `${theme} ${name}: the opacity`);
+        assert.ok(text.contrast >= 4.5, `${theme} ${name}: contrast ${text.contrast.toFixed(2)}:1 is under 4.5:1`);
+      }
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});