@jskit-ai/assistant-runtime 0.1.167 → 0.1.169

package/src/shared/assistantRuntimeConfig.js

@@ -1,7 +1,8 @@
 const assistantRuntimeConfig = Object.freeze({
   configTable: "assistant_config",
   conversationsTable: "assistant_conversations",
-  messagesTable: "assistant_messages"
+  messagesTable: "assistant_messages",
+  turnRequestsTable: "assistant_turn_requests"
 });
 
 export { assistantRuntimeConfig };

package/test/chatServiceLifecycle.test.js

@@ -1,3 +1,4 @@
+import { createMemoryTurnRequests } from "./support/memoryTurnRequests.js";
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createChatService } from "../src/server/services/chatService.js";
@@ -89,6 +90,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
       }));
 
   const chatService = createChatService({
+    turnRequests: createMemoryTurnRequests(),
     attachments,
     aiClientFactory: {
       resolveClient() {
@@ -186,7 +188,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
       {
         context: {
           actor: {
-            id: "user_1"
+            id: "1"
           }
         },
         streamWriter
@@ -510,7 +512,7 @@ test("application-authorized attachments reach the model and survive transcript
   const receipt = { attachmentId: "file-one", fileName: "notes.txt", size: 12 };
   const attachments = { async resolve(request) {
     calls.push(request);
-    assert.equal(request.context.actor.id, "user_1");
+    assert.equal(request.context.actor.id, "1");
     assert.equal(request.conversation.id, "conversation_1");
     if (request.attachmentIds[0] !== "file-one") throw new Error("Attachment access denied");
     return { attachments: [receipt], content: [{ type: "text", text: "Authorized file bytes" }] };

package/test/conversation.browser.test.js

@@ -299,3 +299,53 @@ test("the ready-made UI streams from the real chat service with selected AI conn
     assert.equal(state.transcript.filter(message => message.role === "assistant").length, 1);
   } finally { await browser.close(); await stopProcess(vite); }
 });
+
+test("pending delivery appears immediately and retries the original request without replacing a newer draft", {
+  skip: process.env.JSKIT_ASSISTANT_RUNTIME_BROWSER_INTEGRATION !== "1",
+  timeout: 60_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  const page = await browser.newPage({ viewport: { width: 390, height: 844 } });
+  const held = Promise.withResolvers();
+  const requests = [];
+  const errors = [];
+  page.on("pageerror", error => errors.push(error.message));
+  try {
+    await page.route("**/chat/stream", async route => {
+      requests.push(route.request().postDataJSON());
+      if (requests.length === 1) {
+        await held.promise;
+        await route.fulfill({ status: 503, json: { error: "Temporarily unavailable." } });
+      } else {
+        await route.continue();
+      }
+    });
+    await page.goto(vite.baseURL);
+    const input = page.getByRole("textbox", { name: "Message AI assistant" });
+    await input.fill("Show this immediately.");
+    await input.press("Enter");
+    await expect(page.getByText("Show this immediately.", { exact: true })).toHaveCount(1);
+    await expect(page.locator(".assistant-composer-support__assistant-status")).toHaveText("Sending to assistant…");
+    await expect(input).toHaveValue("");
+    await input.fill("Keep this newer draft.");
+    held.resolve();
+    await expect(page.getByRole("button", { name: "Resend", exact: true })).toBeVisible();
+    await expect(input).toHaveValue("Keep this newer draft.");
+    await page.getByRole("button", { name: "Resend", exact: true }).click();
+    await expect(page.getByLabel("Fixture assistant progress")).toBeVisible();
+    assert.equal(requests.length, 2);
+    assert.deepEqual(requests[1], requests[0]);
+    await expect(page.getByText("Show this immediately.", { exact: true })).toHaveCount(1);
+    await expect(page.getByRole("button", { name: "Resend", exact: true })).toHaveCount(0);
+    await expect(input).toHaveValue("Keep this newer draft.");
+    await page.request.get(`${vite.baseURL}/fixture/next?finish=1`);
+    await expect(page.getByRole("button", { name: "Stop", exact: true })).toHaveCount(0);
+    await expect(input).toHaveValue("Keep this newer draft.");
+    assert.deepEqual(errors, []);
+  } finally {
+    held.resolve();
+    await browser.close();
+    await stopProcess(vite);
+  }
+});

package/test/lazyAppConfig.test.js

@@ -1,3 +1,4 @@
+import { createMemoryTurnRequests } from "./support/memoryTurnRequests.js";
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createSchema } from "json-rest-schema";
@@ -338,6 +339,7 @@ test("registerRoutes returns clear AppError payload for pre-stream assistant fai
 
 test("chat service uses explicit app config when conversations are listed", async () => {
   const chatService = createChatService({
+    turnRequests: createMemoryTurnRequests(),
     aiClientFactory: {
       resolveClient() {
         throw new Error("resolveClient should not be called when listing conversations.");
@@ -388,6 +390,7 @@ test("chat service uses explicit app config when conversations are listed", asyn
 
 test("chat service rejects workspace-scoped assistant surfaces when workspace support is unavailable", async () => {
   const chatService = createChatService({
+    turnRequests: createMemoryTurnRequests(),
     aiClientFactory: {
       resolveClient() {
         throw new Error("resolveClient should not be called when listing conversations.");

package/test/packageMetadata.test.js

@@ -22,7 +22,8 @@ test("assistant-runtime registers providers without install-time authoring machi
   assert.deepEqual(packageMetadata.migrations, { directories: ["migrations"] });
   assert.deepEqual((await readdir(path.join(PACKAGE_ROOT, "migrations"))).sort(), [
     "assistant_config_initial.cjs",
-    "assistant_transcripts_initial.cjs"
+    "assistant_transcripts_initial.cjs",
+    "assistant_turn_requests.cjs"
   ]);
 
   const publicConfig = await readFile(

package/test/support/memoryTurnRequests.js

@@ -0,0 +1,19 @@
+// A test double for lifecycle tests; runtime admission uses the database repository.
+export function createMemoryTurnRequests() {
+  const records = new Map();
+  const key = (scope, messageId) => JSON.stringify([scope, messageId]);
+  return {
+    async find(scope, messageId) { return records.get(key(scope, messageId)) || null; },
+    async claim(scope, request) {
+      const id = key(scope, request.messageId);
+      const existing = records.get(id);
+      if (existing) return { ...existing, acquired: false };
+      const record = { id, request: JSON.parse(JSON.stringify(request)), status: "running", response: null };
+      records.set(id, record);
+      return { ...record, acquired: true };
+    },
+    async update(claim, response, status = "running") {
+      Object.assign(records.get(claim.id), { response: structuredClone(response), status });
+    }
+  };
+}

package/test/turnRequests.test.js

@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, rm } from "node:fs/promises";
+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 { createChatService } from "../src/server/services/chatService.js";
+
+async function database(t) {
+  const dir = await mkdtemp(path.join(tmpdir(), "assistant-requests-"));
+  const connections = [];
+  const connect = () => {
+    const db = knex({ client: "better-sqlite3", connection: { filename: path.join(dir, "requests.db") }, useNullAsDefault: true });
+    connections.push(db);
+    return db;
+  };
+  t.after(async () => { for (const db of connections) await db.destroy(); await rm(dir, { recursive: true, force: true }); });
+  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 };
+}
+
+const scope = { actorUserId: "1", surfaceId: "assistant", workspaceId: null };
+const request = { messageId: "message-1", input: "Do this once.", history: [] };
+
+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 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);
+  await migration.up(db);
+  assert.equal((await db("assistant_turn_requests")).length, 1);
+  assert.equal((await second.claim({ ...scope, actorUserId: "2" }, request)).acquired, true);
+  assert.equal((await second.claim({ ...scope, workspaceId: "10" }, request)).acquired, true);
+  assert.equal((await second.claim({ ...scope, surfaceId: "other" }, request)).acquired, true);
+  await migration.down(db);
+  assert.equal(await db.schema.hasTable("assistant_turn_requests"), false);
+  assert.equal((await db("users")).length, 2);
+});
+
+function service(repository, { provider, transcript = [] } = {}) {
+  return createChatService({
+    turnRequests: repository,
+    aiClientFactory: { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "test", createChatCompletionStream: provider }) },
+    transcriptService: {
+      async createConversationForTurn() { return { conversation: { id: "100" } }; },
+      async appendMessage(_surface, _id, message) { transcript.push(message); },
+      async completeConversation() {}
+    },
+    serviceToolCatalog: { resolveToolSet: () => ({ tools: [] }) },
+    assistantConfigService: { resolveSystemPrompt: async () => "Answer." },
+    appConfig: {
+      surfaceDefinitions: { assistant: { id: "assistant", enabled: true, requiresWorkspace: false, accessPolicyId: "public" } },
+      assistantSurfaces: { assistant: { settingsSurfaceId: "assistant", configScope: "global" } }
+    }
+  });
+}
+
+function run(chat, input = request, { events = [], disconnectAfterCompletion = false } = {}) {
+  const streamWriter = Object.fromEntries(["sendMeta", "sendAssistantDelta", "sendAssistantMessage", "sendToolCall", "sendToolResult", "sendError", "sendDone"]
+    .map(method => [method, event => {
+      if (disconnectAfterCompletion && method === "sendDone") throw new Error("Response lost.");
+      events.push({ method, event });
+    }]));
+  return chat.streamChat({ targetSurfaceId: "assistant", ...input }, { context: { actor: { id: "1" } }, streamWriter });
+}
+
+test("concurrent submissions, lost completion responses and a fresh service replay one provider execution", async t => {
+  const { db, connect } = await database(t);
+  const waiting = Promise.withResolvers();
+  const started = Promise.withResolvers();
+  let calls = 0;
+  const transcript = [];
+  const provider = async function* () {
+    calls++;
+    started.resolve();
+    await waiting.promise;
+    yield { choices: [{ delta: { content: "Completed once." } }] };
+  };
+  const first = service(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 inFlight = [];
+  assert.equal((await run(second, request, { events: inFlight })).status, "unconfirmed");
+  assert.equal(inFlight.find(item => item.method === "sendMeta").event.conversationId, "100");
+  assert.equal(calls, 1);
+  waiting.resolve();
+  await failedResponse;
+  const replay = [];
+  const restarted = service(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);
+  assert.deepEqual(transcript.map(message => message.role), ["user", "assistant"]);
+  await assert.rejects(run(restarted, { ...request, input: "Different request" }), /different request/);
+});
+
+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);
+  await repository.claim(scope, { ...request, conversationId: null, integrationId: "" });
+  let calls = 0;
+  const chat = service(createRepository(connect()), { provider: () => { calls++; throw new Error("Provider failed."); } });
+  assert.equal((await run(chat)).status, "unconfirmed");
+  assert.equal(calls, 0);
+  const failure = { ...request, messageId: "failing-message" };
+  assert.equal((await run(chat, failure)).status, "failed");
+  const replay = [];
+  assert.equal((await run(chat, failure, { events: replay })).status, "failed");
+  assert.equal(calls, 1);
+  assert.match(replay.find(item => item.method === "sendError").event.message, /Provider failed/);
+  await assert.rejects(run(chat, { ...request, messageId: "x".repeat(129) }), /Validation failed/);
+  assert.equal(calls, 1);
+});