@jskit-ai/assistant-runtime 0.2.9 → 0.2.10

package/test/sqlConversationStorage.test.js

@@ -8,6 +8,7 @@ import { AppError } from "@jskit-ai/kernel/server/runtime";
 import { createConversationTranscript } from "@jskit-ai/assistant-core/server/conversation";
 import { verifyConversationStorageContract } from "@jskit-ai/assistant-core/testing/conversation-storage";
 import transcriptsMigration from "../migrations/assistant_transcripts_initial.cjs";
+import summaryMigration from "../migrations/assistant_transcripts_summary.cjs";
 import claimsMigration from "../migrations/assistant_turn_requests.cjs";
 import { createRepository as createConversationsRepository } from "../src/server/repositories/conversationsRepository.js";
 import { createRepository as createMessagesRepository } from "../src/server/repositories/messagesRepository.js";
@@ -16,6 +17,7 @@ import { createSqlConversationStorage } from "../src/server/sqlConversationStora
 import { createAssistantConversationRuntime } from "../src/server/createAssistantRuntime.js";
 import { createTranscriptService } from "../src/server/services/transcriptService.js";
 import { createChatService } from "../src/server/services/chatService.js";
+import { createScriptedModel } from "./support/scriptedModel.js";
 
 async function fixture(t) {
   const directory = await mkdtemp(path.join(tmpdir(), "assistant-sql-runtime-"));
@@ -35,6 +37,7 @@ async function fixture(t) {
   await first.db.schema.createTable("users", table => table.bigInteger("id").primary());
   await first.db("users").insert([{ id: 1 }, { id: 2 }]);
   await transcriptsMigration.up(first.db);
+  await summaryMigration.up(first.db);
   await claimsMigration.up(first.db);
   await first.db.raw("PRAGMA journal_mode = WAL");
   const conversation = actor => first.conversationsRepository.create({ createdByUserId: actor || "1", surfaceId: "assistant", metadata: {} });
@@ -139,7 +142,7 @@ test("historical SQL projection preserves exact rows and blocks ambiguous histor
   assert.deepEqual((await f.storage.preflight(interrupted.id)).issues, [{ code: "unconfirmed_historical_tool", rowIds: [call.id] }]);
 });
 
-test("the SQL facade uses common inference and durable tool rows while supplied history stays request context", async t => {
+test("the SQL facade uses common inference and durable tool rows, and the model's history is the conversation's saved rows", async t => {
   const f = await fixture(t);
   const conversation = await f.conversation();
   await f.messagesRepository.create({ conversationId: conversation.id, role: "user", clientMessageSid: "previous", contentText: "Canonical history outside the selected context" });
@@ -149,14 +152,14 @@ test("the SQL facade uses common inference and durable tool rows while supplied
   let executions = 0;
   const aiClientFactory = { resolveClient(surface, input) {
     resolved.push({ surface, integrationId: input.integrationId, actor: input.context.actor.id });
-    return { enabled: true, provider: "test", defaultModel: "fixture-model", async createChatCompletionStream(request) {
+    return { enabled: true, provider: "test", defaultModel: "fixture-model", model: createScriptedModel(request => {
       requests.push(structuredClone(request.messages));
       const tool = requests.length === 1;
       return (async function* () {
         yield { choices: [{ delta: tool ? { tool_calls: [{ index: 0, id: "lookup", function: { name: "inventory_lookup", arguments: "{}" } }] }
           : { content: "Stored once." }, finish_reason: tool ? "tool_calls" : "stop" }] };
       })();
-    } };
+    }, { model: "fixture-model" }) };
   } };
   const catalog = { limits: { maxToolArgumentBytes: 4096 },
     resolveToolSet: () => ({ tools: [{ name: "inventory_lookup", parameters: { type: "object" } }] }),
@@ -179,7 +182,7 @@ test("the SQL facade uses common inference and durable tool rows while supplied
       assistantSurfaces: { assistant: { settingsSurfaceId: "assistant", configScope: "global" } } } };
   const service = createChatService(dependencies);
   const input = { targetSurfaceId: "assistant", conversationId: conversation.id, messageId: "order/42:review", input: "Read the record",
-    integrationId: "allowed-choice", history: [{ role: "user", content: "Selected request context only" }] };
+    integrationId: "allowed-choice" };
   const options = { context: { actor: { id: "1" } }, streamWriter: Object.fromEntries(
     ["sendMeta", "sendAssistantDelta", "sendAssistantMessage", "sendToolCall", "sendToolResult", "sendError", "sendDone"]
       .map(name => [name, event => events.push({ name, event })])) };
@@ -187,26 +190,24 @@ test("the SQL facade uses common inference and durable tool rows while supplied
   assert.equal(executions, 1);
   assert.equal(requests.length, 2);
   assert.equal(resolved.every(value => value.surface === "assistant" && value.integrationId === "allowed-choice" && value.actor === "1"), true);
-  assert.equal(requests[0].some(message => message.content === "Selected request context only"), true);
-  assert.equal(requests[0].some(message => message.content === "Canonical history outside the selected context"), false);
+  assert.deepEqual(requests[0].slice(1, 3), [{ role: "user", content: "Canonical history outside the selected context" },
+    { role: "assistant", content: "Previous saved answer" }], "The model reads the conversation's saved history, not the browser's");
   assert.deepEqual(JSON.parse(requests[1].find(message => message.role === "tool").content), { found: 1 },
     "The model receives the original action result body, while its durable receipt keeps the full envelope");
   const saved = await rows(f.db);
   assert.equal(saved.messages.filter(row => row.kind === "tool_call").length, 1);
   assert.equal(saved.messages.filter(row => row.kind === "tool_result").length, 1);
   assert.equal(saved.messages.filter(row => row.client_message_sid === input.messageId).length, 1);
-  assert.equal(saved.messages.some(row => row.content_text === "Selected request context only"), false);
-  assert.doesNotMatch(saved.conversations[0].metadata_json, /Selected request context only/);
   assert.doesNotMatch(saved.messages.find(row => row.client_message_sid === input.messageId).metadata_json, /applicationTools/);
   const claimed = await f.db("assistant_turn_requests").first();
   assert.equal(claimed.status, "completed");
-  assert.equal(JSON.parse(claimed.request_json).history[0].content, "Selected request context only");
+  assert.equal(Object.hasOwn(JSON.parse(claimed.request_json), "history"), false);
   assert.equal(events.at(-1).name, "sendDone");
   assert.equal((await service.streamChat(input, options)).status, "completed");
   assert.equal(requests.length, 2, "The original SQL claim replays without inference or duplicate effects");
-  for (const change of [{ actor: { id: "2" } }, { surface: "other" }, { assistantRequest: { conversation, workspace: { id: "77" }, history: [] } }]) {
+  for (const change of [{ actor: { id: "2" } }, { surface: "other" }, { assistantRequest: { conversation, workspace: { id: "77" } } }]) {
     await assert.rejects(runtime.open({ id: conversation.id,
-      context: { actor: { id: "1" }, surface: "assistant", assistantRequest: { conversation, workspace: null, history: [] }, ...change } }),
+      context: { actor: { id: "1" }, surface: "assistant", assistantRequest: { conversation, workspace: null }, ...change } }),
     { code: "conversation_forbidden" });
   }
 });
@@ -223,7 +224,8 @@ test("the SQL facade replays historical inspection failures with their exact pub
   let inference = 0;
   let effects = 0;
   const aiClientFactory = { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "test",
-    createChatCompletionStream() { inference++; assert.fail("Historical inspection cannot invoke inference"); } }) };
+    model: createScriptedModel(() => { inference++; assert.fail("Historical inspection cannot invoke inference"); },
+      { once: () => { inference++; assert.fail("Historical inspection cannot invoke inference"); }, model: "test" }) }) };
   const catalog = { resolveToolSet: () => ({ tools: [] }),
     executeToolCall() { effects++; assert.fail("Historical inspection cannot invoke application effects"); } };
   const runtime = createAssistantConversationRuntime({ ...f, aiClientFactory, toolCatalog: catalog });
@@ -235,7 +237,7 @@ test("the SQL facade replays historical inspection failures with their exact pub
     appConfig: { surfaceDefinitions: { assistant: { enabled: true, requiresWorkspace: false } },
       assistantSurfaces: { assistant: { settingsSurfaceId: "assistant", configScope: "global" } } } };
   const input = { targetSurfaceId: "assistant", conversationId: conversation.id,
-    messageId: "inspect-legacy-history", input: "Continue", history: [] };
+    messageId: "inspect-legacy-history", input: "Continue" };
   const events = [];
   const options = { context: { actor: { id: "1" } }, streamWriter: Object.fromEntries(
     ["sendMeta", "sendAssistantDelta", "sendAssistantMessage", "sendToolCall", "sendToolResult", "sendError", "sendDone"]
@@ -266,7 +268,7 @@ test("the SQL facade replays historical inspection failures with their exact pub
   const oldFailure = { message: "Previously recorded failure", status: 409 };
   const oldInput = { ...input, messageId: "old-failure-receipt" };
   const oldClaim = await turnRequests.claim({ actorUserId: "1", surfaceId: "assistant", workspaceId: null },
-    { conversationId: conversation.id, messageId: oldInput.messageId, input: oldInput.input, history: [], integrationId: "" });
+    { conversationId: conversation.id, messageId: oldInput.messageId, input: oldInput.input, integrationId: "" });
   await turnRequests.update(oldClaim, { failure: oldFailure }, "failed");
   await assert.rejects(restarted.streamChat(oldInput, options), error => {
     assert.equal(error.status, oldFailure.status);
@@ -326,13 +328,13 @@ for (const shape of ["orphan-output", "orphan-tool-result", "unconfirmed-tool"])
     const requests = [];
     let effects = 0;
     const aiClientFactory = { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "fixture-model",
-      async createChatCompletionStream(request) {
+      model: createScriptedModel(request => {
         assert.equal(allowFreshInference, true, "Historical refusal and foreign admission must not start inference");
         requests.push(structuredClone(request.messages));
         return (async function* () {
           yield { choices: [{ delta: { content: "Fresh answer." }, finish_reason: "stop" }] };
         })();
-      } }) };
+      }, { model: "fixture-model" }) }) };
     const catalog = { limits: { maxToolArgumentBytes: 4096 }, resolveToolSet: () => ({ tools: [] }),
       toOpenAiToolSchema: tool => ({ type: "function", function: tool }),
       executeToolCall() { effects++; assert.fail("Retained history cannot repeat an application effect"); } };
@@ -428,3 +430,146 @@ for (const shape of ["orphan-output", "orphan-tool-result", "unconfirmed-tool"])
     assert.deepEqual((await restarted.getConversationMessages(conversation.id, {}, options)).entries, historical);
   });
 }
+
+function recordQueries(db) {
+  const queries = [];
+  const listener = query => queries.push(query.sql);
+  db.on("query", listener);
+  return { queries, stop: () => db.removeListener("query", listener) };
+}
+
+const readsWholeConversation = sql => /from [`"]assistant_messages[`"]/u.test(sql) && /order by/u.test(sql);
+
+async function writeTurns(storage, conversationId, count, prefix = "turn") {
+  await storage.write(conversationId, async transaction => {
+    for (let index = 0; index < count; index += 1) {
+      const turnId = await transaction.nextTurnId();
+      const at = new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString();
+      await transaction.appendMessage(turnId, { role: "user", messageId: `${prefix}-${index}`, text: `Question ${index}`, at,
+        turnMetadata: { runtime: { status: "complete" } } });
+      await transaction.appendMessage(turnId, { role: "assistant", messageId: `${prefix}-${index}:reply-1`, text: `Answer ${index}`, at });
+    }
+  });
+}
+
+test("a long conversation's rows are read once, then each write appends its rows without reading the conversation again", async t => {
+  const f = await fixture(t);
+  const conversation = await f.conversation();
+  await writeTurns(f.storage, conversation.id, 300);
+  const cold = f.connect();
+  let recorded = recordQueries(cold.db);
+  assert.equal((await cold.storage.read(conversation.id, transaction => transaction.listTurnIds())).length, 300);
+  recorded.stop();
+  assert.equal(recorded.queries.filter(readsWholeConversation).length, 2, "A cold server reads the 600 rows once, in pages of 500");
+
+  const measure = async operation => {
+    recorded = recordQueries(cold.db);
+    const result = await operation();
+    recorded.stop();
+    return { result, queries: recorded.queries };
+  };
+  const appendTurn = messageId => cold.storage.write(conversation.id, async transaction => {
+    const turnId = await transaction.nextTurnId();
+    await transaction.appendMessage(turnId, { role: "user", messageId, text: "One more", at: "2026-02-01T00:00:00.000Z" });
+    await transaction.updateTurnMetadata(turnId, { runtime: { status: "running" } });
+    return turnId;
+  });
+  const write = await measure(() => appendTurn("after-300"));
+  assert.equal(write.result, "000301");
+  assert.deepEqual(write.queries.filter(readsWholeConversation), []);
+  assert.ok(write.queries.length <= 12, `A write issues a constant number of queries, not one per stored row (${write.queries.length})`);
+  const read = await measure(() => cold.storage.read(conversation.id, transaction => transaction.readTurn("000301")));
+  assert.equal(read.result.user.text, "One more");
+  assert.deepEqual(read.result.metadata, { runtime: { status: "running" } });
+  assert.deepEqual(read.queries.filter(readsWholeConversation), []);
+  assert.ok(read.queries.length <= 5, `A read issues a constant number of queries (${read.queries.length})`);
+
+  await writeTurns(cold.storage, conversation.id, 50, "later");
+  const longer = await measure(() => appendTurn("after-350"));
+  assert.equal(longer.result, "000352");
+  assert.deepEqual(longer.queries, write.queries, "The same write issues the same queries however long the conversation is");
+  const answer = await measure(() => cold.storage.write(conversation.id, transaction =>
+    transaction.replaceAssistant("000301", { role: "assistant", messageId: "after-300:reply-1", text: "Answered", at: "2026-02-01T00:00:01.000Z" })));
+  assert.deepEqual(answer.queries.filter(readsWholeConversation), []);
+
+  const fresh = f.connect();
+  const expected = await fresh.storage.read(conversation.id, async transaction =>
+    Promise.all((await transaction.listTurnIds()).map(id => transaction.readTurn(id))));
+  const cached = await cold.storage.read(conversation.id, async transaction =>
+    Promise.all((await transaction.listTurnIds()).map(id => transaction.readTurn(id))));
+  assert.equal(expected.length, 352);
+  assert.deepEqual(cached, expected, "Cached rows project exactly as a fresh read of the database");
+});
+
+test("a server sees another server's saves, direct row inserts and conversation updates at once", async t => {
+  const f = await fixture(t);
+  const conversation = await f.conversation();
+  const other = f.connect();
+  await writeTurns(f.storage, conversation.id, 2);
+  assert.deepEqual(await f.storage.read(conversation.id, transaction => transaction.listTurnIds()), ["000001", "000002"]);
+  await writeTurns(other.storage, conversation.id, 1, "other");
+  assert.deepEqual(await f.storage.read(conversation.id, transaction => transaction.listTurnIds()), ["000001", "000002", "000003"]);
+  await other.storage.write(conversation.id, transaction => transaction.updateTurnMetadata("000001", { product: { edited: true } }));
+  assert.deepEqual((await f.storage.read(conversation.id, transaction => transaction.readTurn("000001"))).metadata,
+    { runtime: { status: "complete" }, product: { edited: true } });
+  assert.equal(await f.storage.write(conversation.id, transaction => transaction.nextTurnId()), "000004");
+
+  await f.messagesRepository.create({ conversationId: conversation.id, actorUserId: "1", role: "user", kind: "chat",
+    clientMessageSid: "imported", contentText: "Imported question",
+    metadata: { surfaceId: "assistant", conversationRuntime: { turnId: "000009" } } });
+  assert.equal((await f.storage.read(conversation.id, transaction => transaction.readTurn("000009"))).user.text, "Imported question");
+
+  await f.conversationsRepository.updateById(conversation.id, { metadata: { runtime: { external: true } } });
+  assert.deepEqual(await f.storage.read(conversation.id, transaction => transaction.readMetadata()), { runtime: { external: true } });
+});
+
+test("a save that fails to commit leaves the cached rows on what the database holds", async t => {
+  const f = await fixture(t);
+  const conversation = await f.conversation();
+  let fail = false;
+  const storage = createSqlConversationStorage({ conversationsRepository: f.conversationsRepository,
+    messagesRepository: { ...f.messagesRepository, async create(input, options) {
+      const result = await f.messagesRepository.create(input, options);
+      if (fail) throw new Error("forced-row-commit-failure");
+      return result;
+    } } });
+  await writeTurns(storage, conversation.id, 2);
+  assert.equal((await storage.read(conversation.id, transaction => transaction.listTurnIds())).length, 2);
+  fail = true;
+  await assert.rejects(writeTurns(storage, conversation.id, 1, "failed"), /forced-row-commit-failure/);
+  fail = false;
+  assert.deepEqual(await storage.read(conversation.id, transaction => transaction.listTurnIds()), ["000001", "000002"]);
+  await writeTurns(storage, conversation.id, 1, "next");
+  const saved = await f.messagesRepository.listByConversationScope(conversation.id);
+  assert.deepEqual(saved.map(row => row.seq), [1, 2, 3, 4, 5, 6]);
+  assert.equal(saved.at(-2).clientMessageSid, "next-0");
+  assert.equal((await f.conversationsRepository.findById(conversation.id)).messageCount, 6);
+});
+
+test("the summary and the last turn it covers are saved on the conversation row, and a new server reads only the turns after it", async t => {
+  const f = await fixture(t);
+  const conversation = await f.conversation();
+  await writeTurns(f.storage, conversation.id, 4);
+  const before = await rows(f.db);
+  await f.storage.write(conversation.id, transaction => transaction.writeSummary({ text: "Turns one to three.", throughTurnId: "000003" }));
+  const saved = await f.db("assistant_conversations").where({ id: conversation.id }).first();
+  assert.equal(saved.summary_text, "Turns one to three.");
+  assert.equal(saved.summary_through_turn_id, "000003");
+  assert.notEqual(saved.transcript_revision, before.conversations[0].transcript_revision);
+  assert.deepEqual((await rows(f.db)).messages, before.messages, "Compaction never deletes or changes messages");
+  assert.doesNotMatch(saved.metadata_json || "", /Turns one to three/u);
+  assert.equal(Object.hasOwn(await f.conversationsRepository.findById(conversation.id), "summary"), false,
+    "Conversation records sent to the browser do not carry the summary");
+
+  const restarted = f.connect();
+  const later = await restarted.storage.read(conversation.id, async transaction => {
+    const summary = await transaction.readSummary();
+    return { summary, turns: await transaction.readTurnsAfter(summary.throughTurnId) };
+  });
+  assert.deepEqual(later.summary, { text: "Turns one to three.", throughTurnId: "000003" });
+  assert.deepEqual(later.turns.map(turn => [turn.turnId, turn.user.text, turn.assistant.text]), [["000004", "Question 3", "Answer 3"]]);
+
+  await restarted.storage.write(conversation.id, transaction => transaction.writeSummary({ text: "Turns one to four.", throughTurnId: "000004" }));
+  assert.deepEqual(await f.storage.read(conversation.id, transaction => transaction.readSummary()),
+    { text: "Turns one to four.", throughTurnId: "000004" }, "Another server's summary is read at once");
+});

package/test/support/memoryAssistantRows.js

@@ -3,7 +3,7 @@
  */
 export function createMemoryAssistantRows({ id = "conversation_1", surfaceId = "assistant", messages = [] } = {}) {
   let state = { conversation: { id, workspaceId: null, createdByUserId: "1", surfaceId,
-    title: "New conversation", status: "active", messageCount: 0, metadata: {} }, messages: [] };
+    title: "New conversation", status: "active", messageCount: 0, metadata: {} }, transcript: { revision: "", summary: null }, messages: [] };
   let pending = Promise.resolve();
   const read = options => options?.trx || state;
   const conversationsRepository = {
@@ -18,6 +18,10 @@ export function createMemoryAssistantRows({ id = "conversation_1", surfaceId = "
       Object.assign(target.conversation, structuredClone(patch));
       return structuredClone(target.conversation);
     },
+    async readTranscriptState(value, options) { return value === id ? structuredClone(read(options).transcript) : null; },
+    async writeTranscriptState(value, transcript, options) {
+      if (value === id) read(options).transcript = structuredClone(transcript);
+    },
     transaction(operation) {
       const next = pending.then(async () => {
         const trx = structuredClone(state);
@@ -34,6 +38,7 @@ export function createMemoryAssistantRows({ id = "conversation_1", surfaceId = "
     async listByConversationScope(_id, _scope, { page, pageSize }, options) {
       return structuredClone(read(options).messages.slice((page - 1) * pageSize, page * pageSize));
     },
+    async lastSequence(_id, options) { return read(options).messages.length; },
     async create(payload, options) {
       const rows = read(options).messages;
       const row = { ...structuredClone(payload), id: String(rows.length + 1), seq: rows.length + 1,

package/test/support/scriptedModel.js

@@ -0,0 +1,32 @@
+import { createAiConnectionClient } from "@jskit-ai/assistant-core/server";
+
+const encoder = new TextEncoder();
+
+/** An AI SDK model on an OpenAI-compatible endpoint that answers from a script. A streamed
+ * request (a reply step) gets `stream(body)`: OpenAI stream chunks (an async iterable), passed on
+ * as they come. The engine's other calls (checks, accounts, summaries) get `once(body)` as one
+ * message; by default an empty one, which a check reads as nothing to report.
+ */
+export function createScriptedModel(stream, { once = () => "", model = "test-model" } = {}) {
+  const fetch = async (_url, request) => {
+    const body = JSON.parse(request.body);
+    if (!body.stream) {
+      return Response.json({ id: "scripted", object: "chat.completion", created: 0, model,
+        choices: [{ index: 0, message: { role: "assistant", content: await once(body) }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
+    }
+    const chunks = (await stream(body))[Symbol.asyncIterator]();
+    const frame = chunk => ({ id: "scripted", object: "chat.completion.chunk", created: 0, model, ...chunk });
+    return new Response(new ReadableStream({
+      async pull(controller) {
+        const { value, done } = await chunks.next();
+        if (done) {
+          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          controller.close();
+        } else controller.enqueue(encoder.encode(`data: ${JSON.stringify(frame(value))}\n\n`));
+      }
+    }), { headers: { "content-type": "text/event-stream" } });
+  };
+  return createAiConnectionClient({ providerId: "test", model, sdkPackage: "@ai-sdk/openai-compatible",
+    apiKey: "test", baseURL: "http://test.invalid/v1" }, { fetch }).model;
+}

package/test/turnRequests.test.js

@@ -9,6 +9,7 @@ import { createRepository } from "../src/server/repositories/turnRequestsReposit
 import { createChatService } from "../src/server/services/chatService.js";
 import { createAssistantConversationRuntime } from "../src/server/createAssistantRuntime.js";
 import { createMemoryAssistantRows } from "./support/memoryAssistantRows.js";
+import { createScriptedModel } from "./support/scriptedModel.js";
 
 async function database(t) {
   const dir = await mkdtemp(path.join(tmpdir(), "assistant-requests-"));
@@ -27,7 +28,7 @@ async function database(t) {
 }
 
 const scope = { actorUserId: "1", surfaceId: "assistant", workspaceId: null };
-const request = { messageId: "message-1", input: "Do this once.", history: [] };
+const request = { messageId: "message-1", input: "Do this once." };
 
 test("migration preserves existing claims and database uniqueness arbitrates independent connections", async t => {
   const { db, connect } = await database(t);
@@ -49,7 +50,8 @@ test("migration preserves existing claims and database uniqueness arbitrates ind
 function service(repository, { provider, transcript = [] } = {}) {
   const dependencies = {
     turnRequests: repository,
-    aiClientFactory: { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "test", createChatCompletionStream: provider }) },
+    aiClientFactory: { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "test",
+      model: provider && createScriptedModel(body => provider({ messages: body.messages }), { model: "test" }) }) },
     transcriptService: {
       async createConversationForTurn() { return { conversation: { id: "100" } }; },
       async completeConversation() {}

package/test/usersForeignKeysMigration.test.js

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import knex from "knex";
+import configMigration from "../migrations/assistant_config_initial.cjs";
+import transcriptsMigration from "../migrations/assistant_transcripts_initial.cjs";
+import turnRequestsMigration from "../migrations/assistant_turn_requests.cjs";
+import usersForeignKeysMigration from "../migrations/constraints/assistant_users_foreign_keys.cjs";
+
+const USER_KEYS = [
+  { table: "assistant_conversations", from: "created_by_user_id", on_delete: "SET NULL" },
+  { table: "assistant_messages", from: "actor_user_id", on_delete: "SET NULL" },
+  { table: "assistant_turn_requests", from: "actor_user_id", on_delete: "CASCADE" }
+];
+
+async function usersKeys(db) {
+  const keys = [];
+  for (const { table } of USER_KEYS) {
+    for (const key of await db.raw("PRAGMA foreign_key_list(??)", [table])) {
+      if (key.table === "users") keys.push({ table, from: key.from, on_delete: key.on_delete });
+    }
+  }
+  return keys;
+}
+
+test("the assistant tables are created before users exists and get their users keys in the constraints phase", async (t) => {
+  const db = knex({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+
+  // Package table migrations run before the application's migrations, which may create users.
+  await configMigration.up(db);
+  await transcriptsMigration.up(db);
+  await turnRequestsMigration.up(db);
+  assert.deepEqual(await usersKeys(db), []);
+
+  await assert.rejects(usersForeignKeysMigration.up(db), /the users table does not exist/u);
+  await db.schema.createTable("users", (table) => table.bigInteger("id").primary());
+  await usersForeignKeysMigration.up(db);
+  assert.deepEqual(await usersKeys(db), USER_KEYS);
+
+  // Tables that already have their users keys, as databases migrated before this phase do, gain no duplicate.
+  await usersForeignKeysMigration.up(db);
+  assert.deepEqual(await usersKeys(db), USER_KEYS);
+
+  await usersForeignKeysMigration.down(db);
+  assert.deepEqual(await usersKeys(db), []);
+});

package/test/workspacesForeignKeysMigration.test.js

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import knex from "knex";
+import configMigration from "../migrations/assistant_config_initial.cjs";
+import transcriptsMigration from "../migrations/assistant_transcripts_initial.cjs";
+import workspacesForeignKeysMigration from "../migrations/constraints/assistant_workspaces_foreign_keys.cjs";
+
+const TABLES = ["assistant_config", "assistant_conversations", "assistant_messages"];
+
+async function workspaceKeys(db) {
+  const keys = [];
+  for (const table of TABLES) {
+    for (const key of await db.raw("PRAGMA foreign_key_list(??)", [table])) {
+      if (key.table === "workspaces") keys.push({ table, from: key.from, on_delete: key.on_delete });
+    }
+  }
+  return keys;
+}
+
+async function freshTables(t) {
+  const db = knex({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  // Package table migrations run before workspaces-core's, so no workspaces table exists yet.
+  await configMigration.up(db);
+  await transcriptsMigration.up(db);
+  assert.deepEqual(await workspaceKeys(db), []);
+  return db;
+}
+
+test("the assistant tables get their workspaces keys in the constraints phase, once", async (t) => {
+  const db = await freshTables(t);
+  await db.schema.createTable("workspaces", (table) => table.bigInteger("id").primary());
+  await workspacesForeignKeysMigration.up(db);
+  const keys = TABLES.map((table) => ({ table, from: "workspace_id", on_delete: "CASCADE" }));
+  assert.deepEqual(await workspaceKeys(db), keys);
+
+  // Tables that already have their workspaces keys, as databases migrated before this phase do, are unchanged.
+  await workspacesForeignKeysMigration.up(db);
+  assert.deepEqual(await workspaceKeys(db), keys);
+
+  await workspacesForeignKeysMigration.down(db);
+  assert.deepEqual(await workspaceKeys(db), []);
+});
+
+test("an application without a workspaces table gets no workspaces keys", async (t) => {
+  const db = await freshTables(t);
+  await workspacesForeignKeysMigration.up(db);
+  assert.deepEqual(await workspaceKeys(db), []);
+});
+
+test("rows whose workspace is gone stop the migration with their table, column and count, and stay", async (t) => {
+  const db = await freshTables(t);
+  await db.schema.createTable("workspaces", (table) => table.bigInteger("id").primary());
+  await db("workspaces").insert({ id: 1 });
+  await db("assistant_config").insert([
+    { target_surface_id: "app", scope_key: "workspace:1", workspace_id: 1 },
+    { target_surface_id: "app", scope_key: "workspace:7", workspace_id: 7 },
+    { target_surface_id: "app", scope_key: "workspace:8", workspace_id: 8 }
+  ]);
+  await assert.rejects(
+    workspacesForeignKeysMigration.up(db),
+    /assistant_config\.workspace_id foreign key to workspaces\.id: 2 assistant_config row\(s\) have a workspace_id with no workspaces row/u
+  );
+  assert.equal((await db("assistant_config")).length, 3);
+  assert.deepEqual(await workspaceKeys(db), []);
+});

package/src/client/support/accessDenied.js

@@ -1,6 +0,0 @@
-/** Whether a conversation failure means the viewer lost access to it. */
-function isAccessDenied(error) {
-  return [401, 403].includes(Number(error.status || error.statusCode));
-}
-
-export { isAccessDenied };