@jskit-ai/assistant-runtime 0.2.29 → 0.2.31

package/test/sqlConversationStorage.test.js

@@ -11,15 +11,13 @@ import { verifyConversationStorageContract } from "@jskit-ai/assistant-core/test
 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";
-import { createRepository as createTurnRequestsRepository } from "../src/server/repositories/turnRequestsRepository.js";
 import { createSqlConversationStorage } from "../src/server/sqlConversationStorage.js";
 import { createAssistantConversationRuntime } from "../src/server/createAssistantRuntime.js";
 import { createTranscriptService } from "../src/server/services/transcriptService.js";
 import { createChatService } from "../src/server/services/chatService.js";
 import { NO_PERSON_CONTEXT, createPersonContextPrompt } from "../src/server/support/personContext.js";
 import { createScriptedModel } from "./support/scriptedModel.js";
+import { createTestAssistantStore } from "./support/assistantStore.js";
 
 // The chat service of an application that supplies no facts about the person.
 const NO_FACTS = createPersonContextPrompt({ personContext: NO_PERSON_CONTEXT, logger: silentLogger });
@@ -27,18 +25,25 @@ const NO_FACTS = createPersonContextPrompt({ personContext: NO_PERSON_CONTEXT, l
 async function fixture(t) {
   const directory = await mkdtemp(path.join(tmpdir(), "assistant-sql-runtime-"));
   const clients = [];
-  function connect() {
+  const stores = [];
+  async function connect() {
     const db = knex({ client: "better-sqlite3", connection: { filename: path.join(directory, "assistant.sqlite") },
       useNullAsDefault: true, pool: { min: 1, max: 1, afterCreate(connection, done) {
         connection.pragma("busy_timeout = 0");
         done(null, connection);
       } } });
     clients.push(db);
-    const repositories = { conversationsRepository: createConversationsRepository(db), messagesRepository: createMessagesRepository(db) };
-    return { db, ...repositories, storage: createSqlConversationStorage(repositories) };
+    const store = await createTestAssistantStore(db);
+    stores.push(store);
+    const repositories = { conversationsRepository: store.conversations, messagesRepository: store.messages };
+    return { db, turnRequests: store.turnRequests, ...repositories, storage: createSqlConversationStorage(repositories) };
   }
-  t.after(async () => { for (const client of clients) await client.destroy(); await rm(directory, { recursive: true, force: true }); });
-  const first = connect();
+  t.after(async () => {
+    for (const store of stores) await store.close();
+    for (const client of clients) await client.destroy();
+    await rm(directory, { recursive: true, force: true });
+  });
+  const first = await connect();
   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);
@@ -100,7 +105,7 @@ test("the existing runtime storage contract uses the original SQL rows and rolls
 test("independent SQL connections serialize authored receipt and sequence allocation", async t => {
   const f = await fixture(t);
   const conversation = await f.conversation();
-  const second = f.connect();
+  const second = await f.connect();
   const transcripts = [f.storage, second.storage].map(storage => createConversationTranscript({ storage }));
   const input = { messageId: "invoice/42:follow-up", text: "Only once" };
   const results = await Promise.all(transcripts.map(transcript => transcript.writeConversationUserMessage(conversation.id, input)));
@@ -181,7 +186,7 @@ test("the SQL facade uses common inference and durable tool rows, and the model'
   const runtime = createAssistantConversationRuntime({ ...f, aiClientFactory, toolCatalog: catalog });
   t.after(() => runtime.close());
   const dependencies = { conversationRuntime: runtime, aiClientFactory, serviceToolCatalog: catalog,
-    transcriptService: createTranscriptService(f), turnRequests: createTurnRequestsRepository(f.db),
+    transcriptService: createTranscriptService(f), turnRequests: f.turnRequests,
     assistantConfigService: { resolveSystemPrompt: async () => "Retained SQL instructions" },
     personContextPrompt: NO_FACTS,
     appConfig: { surfaceDefinitions: { assistant: { enabled: true, requiresWorkspace: false } },
@@ -236,7 +241,7 @@ test("the SQL facade replays historical inspection failures with their exact pub
     executeToolCall() { effects++; assert.fail("Historical inspection cannot invoke application effects"); } };
   const runtime = createAssistantConversationRuntime({ ...f, aiClientFactory, toolCatalog: catalog });
   t.after(() => runtime.close());
-  const turnRequests = createTurnRequestsRepository(f.db);
+  const turnRequests = f.turnRequests;
   const dependencies = { conversationRuntime: runtime, aiClientFactory, serviceToolCatalog: catalog,
     transcriptService: createTranscriptService(f), turnRequests,
     assistantConfigService: { resolveSystemPrompt: async () => "Read the supplied context" },
@@ -260,7 +265,7 @@ test("the SQL facade replays historical inspection failures with their exact pub
   await assert.rejects(createChatService(dependencies).streamChat(input, options), requireInspection);
   const receipt = await f.db("assistant_turn_requests").first();
   assert.equal(receipt.status, "failed");
-  const restarted = createChatService({ ...dependencies, turnRequests: createTurnRequestsRepository(f.db) });
+  const restarted = createChatService({ ...dependencies, turnRequests: f.turnRequests });
   await assert.rejects(restarted.streamChat(input, options), requireInspection);
   assert.deepEqual(JSON.parse(receipt.response_json).failure, {
     message: "This conversation has ambiguous historical SQL rows. Inspect the reported rows offline before using the common runtime; no history was changed.",
@@ -347,7 +352,7 @@ for (const shape of ["orphan-output", "orphan-tool-result", "unconfirmed-tool"])
       executeToolCall() { effects++; assert.fail("Retained history cannot repeat an application effect"); } };
     const runtime = createAssistantConversationRuntime({ ...f, aiClientFactory, toolCatalog: catalog });
     t.after(() => runtime.close());
-    const turnRequests = createTurnRequestsRepository(f.db);
+    const turnRequests = f.turnRequests;
     const dependencies = { conversationRuntime: runtime, aiClientFactory, serviceToolCatalog: catalog,
       transcriptService: createTranscriptService(f), turnRequests,
       assistantConfigService: { resolveSystemPrompt: async () => "Read only the admitted request" },
@@ -376,7 +381,7 @@ for (const shape of ["orphan-output", "orphan-tool-result", "unconfirmed-tool"])
       return true;
     });
     const receipt = await f.db("assistant_turn_requests").first();
-    const restarted = createChatService({ ...dependencies, turnRequests: createTurnRequestsRepository(f.db) });
+    const restarted = createChatService({ ...dependencies, turnRequests: f.turnRequests });
     await assert.rejects(restarted.streamChat(input, options), error => {
       assert.equal(error.status, 409);
       assert.equal(error.code, "assistant_history_inspection_required");
@@ -464,7 +469,7 @@ test("a long conversation's rows are read once, then each write appends its rows
   const f = await fixture(t);
   const conversation = await f.conversation();
   await writeTurns(f.storage, conversation.id, 300);
-  const cold = f.connect();
+  const cold = await f.connect();
   let recorded = recordQueries(cold.db);
   assert.equal((await cold.storage.read(conversation.id, transaction => transaction.listTurnIds())).length, 300);
   recorded.stop();
@@ -485,12 +490,14 @@ test("a long conversation's rows are read once, then each write appends its rows
   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})`);
+  // BEGIN, the conversation's lock, its last seq, the message's insert and read-back, one update of the conversation, COMMIT;
+  // SQLite takes the lock with a no-op write and then reads the row.
+  assert.ok(write.queries.length <= 8, `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})`);
+  assert.ok(read.queries.length <= 4, `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"));
@@ -500,7 +507,7 @@ test("a long conversation's rows are read once, then each write appends its rows
     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 fresh = await 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 =>
@@ -512,7 +519,7 @@ test("a long conversation's rows are read once, then each write appends its rows
 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();
+  const other = await 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");
@@ -569,7 +576,7 @@ test("the summary and the last turn it covers are saved on the conversation row,
   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 restarted = await 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) };

package/test/support/assistantStore.js

@@ -0,0 +1,39 @@
+import { ActionProvider } from "@jskit-ai/kernel/server/actions";
+import { EventProvider } from "@jskit-ai/kernel/server/runtime";
+import { silentLogger } from "@jskit-ai/kernel/server/runtime/logger";
+import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
+import { ResourceRuntimeProvider } from "@jskit-ai/resource-runtime/server";
+import { AssistantStoreFeature } from "../../src/server/AssistantStoreFeature.js";
+
+/**
+ * The assistant's repositories on a test's own Knex, as an application gets
+ * them: AssistantStoreFeature owning its tables through the resource runtime.
+ * `close()` shuts that runtime down; the Knex stays the test's.
+ * @param {import("knex").Knex} knex
+ */
+export async function createTestAssistantStore(knex) {
+  let repositories = null;
+  const runtime = createCapabilityRuntime({
+    inputs: { "runtime.logger": silentLogger },
+    providers: [
+      EventProvider,
+      ActionProvider,
+      defineProvider({ id: "test.database", provides: { value: "runtime.database" }, setup: () => ({ value: { knex } }) }),
+      ResourceRuntimeProvider,
+      AssistantStoreFeature,
+      defineProvider({
+        id: "test.assistant-store",
+        requires: { store: "assistant.repositories" },
+        setup({ store }) {
+          repositories = store;
+          return {};
+        }
+      })
+    ]
+  });
+  await runtime.start();
+  return {
+    ...repositories,
+    close: () => runtime.shutdown()
+  };
+}

package/test/support/memoryAssistantRows.js

@@ -18,14 +18,21 @@ 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);
+    async findWithTranscriptState(value, options) {
+      if (value !== id) return null;
+      const { conversation, transcript } = read(options);
+      return structuredClone({ conversation, ...transcript });
+    },
+    async writeTranscriptState(value, { changes = {}, ...transcript }, options) {
+      if (value !== id) return;
+      const target = read(options);
+      target.transcript = structuredClone(transcript);
+      Object.assign(target.conversation, structuredClone(changes));
     },
     transaction(operation) {
       const next = pending.then(async () => {
         const trx = structuredClone(state);
-        const value = await operation(trx);
+        const value = await operation({ trx });
         state = trx;
         messages.splice(0, messages.length, ...structuredClone(state.messages));
         return value;

package/test/turnRequests.test.js

@@ -5,37 +5,60 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import knex from "knex";
 import migration from "../migrations/assistant_turn_requests.cjs";
-import { createRepository } from "../src/server/repositories/turnRequestsRepository.js";
 import { silentLogger } from "@jskit-ai/kernel/server/runtime/logger";
 import { createChatService } from "../src/server/services/chatService.js";
 import { NO_PERSON_CONTEXT, createPersonContextPrompt } from "../src/server/support/personContext.js";
 import { createAssistantConversationRuntime } from "../src/server/createAssistantRuntime.js";
 import { createMemoryAssistantRows } from "./support/memoryAssistantRows.js";
 import { createScriptedModel } from "./support/scriptedModel.js";
+import { createTestAssistantStore } from "./support/assistantStore.js";
 
 async function database(t) {
   const dir = await mkdtemp(path.join(tmpdir(), "assistant-requests-"));
   const connections = [];
+  const stores = [];
+  // Two connections in one process: a connection that waited for SQLite's lock would block the event loop the lock's
+  // holder needs to commit, so each finds the database busy at once, and its write's transaction runs again.
   const connect = () => {
-    const db = knex({ client: "better-sqlite3", connection: { filename: path.join(dir, "requests.db") }, useNullAsDefault: true });
+    const db = knex({
+      client: "better-sqlite3",
+      connection: { filename: path.join(dir, "requests.db") },
+      useNullAsDefault: true,
+      pool: {
+        afterCreate(connection, done) {
+          connection.pragma("busy_timeout = 0");
+          done(null, connection);
+        }
+      }
+    });
     connections.push(db);
     return db;
   };
-  t.after(async () => { for (const db of connections) await db.destroy(); await rm(dir, { recursive: true, force: true }); });
+  t.after(async () => {
+    for (const store of stores) await store.close();
+    for (const db of connections) await db.destroy();
+    await rm(dir, { recursive: true, force: true });
+  });
+  // The turn requests repository on a connection, as AssistantStoreFeature builds it.
+  const createRepository = async (connection) => {
+    const store = await createTestAssistantStore(connection);
+    stores.push(store);
+    return store.turnRequests;
+  };
   const db = connect();
   await db.schema.createTable("users", table => table.bigInteger("id").primary());
   await db("users").insert([{ id: 1 }, { id: 2 }]);
   await migration.up(db);
-  return { db, connect };
+  return { db, connect, createRepository };
 }
 
 const scope = { actorUserId: "1", surfaceId: "assistant", workspaceId: null };
 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);
-  const first = createRepository(db);
-  const second = createRepository(connect());
+  const { db, connect, createRepository } = await database(t);
+  const first = await createRepository(db);
+  const second = await createRepository(connect());
   const claims = await Promise.all([first.claim(scope, request), second.claim(scope, request)]);
   assert.equal(claims.filter(claim => claim.acquired).length, 1);
   assert.equal((await db("assistant_turn_requests")).length, 1);
@@ -84,7 +107,7 @@ function run(chat, input = request, { events = [], disconnectAfterCompletion = f
 }
 
 test("concurrent submissions, lost completion responses and a fresh service replay one provider execution", async t => {
-  const { db, connect } = await database(t);
+  const { db, connect, createRepository } = await database(t);
   const waiting = Promise.withResolvers();
   const started = Promise.withResolvers();
   let calls = 0;
@@ -96,11 +119,11 @@ test("concurrent submissions, lost completion responses and a fresh service repl
     yield { choices: [{ delta: { content: "Completed once." } }] };
     yield { choices: [{ delta: {}, finish_reason: "stop" }] };
   };
-  const first = service(createRepository(db), { provider, transcript });
+  const first = service(await createRepository(db), { provider, transcript });
   const pending = run(first, request, { disconnectAfterCompletion: true });
   const failedResponse = assert.rejects(pending, /Response lost/);
   await started.promise;
-  const second = service(createRepository(connect()), { provider, transcript });
+  const second = service(await createRepository(connect()), { provider, transcript });
   const inFlight = [];
   assert.equal((await run(second, request, { events: inFlight })).status, "unconfirmed");
   assert.equal(inFlight.find(item => item.method === "sendMeta").event.conversationId, "100");
@@ -108,7 +131,7 @@ test("concurrent submissions, lost completion responses and a fresh service repl
   waiting.resolve();
   await failedResponse;
   const replay = [];
-  const restarted = service(createRepository(connect()), { provider: () => { throw new Error("Replay must not invoke the provider."); } });
+  const restarted = service(await createRepository(connect()), { provider: () => { throw new Error("Replay must not invoke the provider."); } });
   assert.equal((await run(restarted, request, { events: replay })).status, "completed");
   assert.equal(replay.find(item => item.method === "sendAssistantMessage").event.text, "Completed once.");
   assert.equal(calls, 1);
@@ -117,11 +140,11 @@ test("concurrent submissions, lost completion responses and a fresh service repl
 });
 
 test("an interrupted claim is never stolen after restart, and provider failures replay without executing again", async t => {
-  const { db, connect } = await database(t);
-  const repository = createRepository(db);
+  const { db, connect, createRepository } = await database(t);
+  const repository = await createRepository(db);
   await repository.claim(scope, { ...request, conversationId: null, integrationId: "" });
   let calls = 0;
-  const chat = service(createRepository(connect()), { provider: () => { calls++; throw new Error("Provider failed."); } });
+  const chat = service(await createRepository(connect()), { provider: () => { calls++; throw new Error("Provider failed."); } });
   const unconfirmed = [];
   assert.equal((await run(chat, request, { events: unconfirmed })).status, "unconfirmed");
   assert.equal(unconfirmed.find(item => item.method === "sendError").event.messageCode, "assistant.runtime.request.unconfirmed");

package/test/usersForeignKeysMigration.test.js

@@ -5,6 +5,9 @@ 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";
+import workspacesForeignKeysMigration from "../migrations/constraints/assistant_workspaces_foreign_keys.cjs";
+import { checkForeignKeys } from "@jskit-ai/resource-runtime/server";
+import * as assistantResources from "../src/server/repositories/assistantResources.js";
 
 const USER_KEYS = [
   { table: "assistant_conversations", from: "created_by_user_id", on_delete: "SET NULL" },
@@ -44,3 +47,24 @@ test("the assistant tables are created before users exists and get their users k
   await usersForeignKeysMigration.down(db);
   assert.deepEqual(await usersKeys(db), []);
 });
+
+test("the assistant table resources declare the foreign keys their migrations always create", async (t) => {
+  const db = knex({ client: "better-sqlite3", connection: { filename: ":memory:" }, useNullAsDefault: true });
+  t.after(() => db.destroy());
+  const resources = Object.values(assistantResources);
+  const tables = resources.map((resource) => resource.tableName);
+  for (const migration of [configMigration, transcriptsMigration, turnRequestsMigration]) await migration.up(db);
+  await db.schema.createTable("users", (table) => table.bigInteger("id").primary());
+  await usersForeignKeysMigration.up(db);
+  assert.deepEqual(await checkForeignKeys({ knex: db, resources, tables }), { missing: [], undeclared: [] });
+
+  // An application with workspaces also gets the workspace_id keys, which no resource declares: not every
+  // application has them.
+  await db.schema.createTable("workspaces", (table) => table.bigInteger("id").primary());
+  await workspacesForeignKeysMigration.up(db);
+  const { missing, undeclared } = await checkForeignKeys({ knex: db, resources, tables });
+  assert.deepEqual(missing, []);
+  assert.deepEqual(undeclared.map(({ tableName, columns, referencedTableName }) => ({ tableName, columns, referencedTableName })),
+    ["assistant_config", "assistant_conversations", "assistant_messages"]
+      .map((tableName) => ({ tableName, columns: ["workspace_id"], referencedTableName: "workspaces" })));
+});