@jskit-ai/assistant-runtime 0.1.193 → 0.1.194

package/test/registerFastifyConversations.test.js

@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import { EventEmitter, once } from "node:events";
+import test from "node:test";
+import Fastify from "fastify";
+import { createConversationRuntime, createMemoryConversationStorage } from "@jskit-ai/assistant-core/server/conversation";
+import { createSocketIoClient } from "@jskit-ai/realtime/client/runtime";
+import { registerFastifyConversations } from "../src/server/registerFastifyConversations.js";
+import { ASSISTANT_CONVERSATION_EVENT, ASSISTANT_CONVERSATION_SUBSCRIBE } from "../src/shared/conversationRealtime.js";
+
+const config = {
+  surfaceDefinitions: { home: { enabled: true, requiresWorkspace: false } },
+  assistantSurfaces: { home: { settingsSurfaceId: "home", configScope: "global" } }
+};
+const route = id => `/api/assistant/home/conversations/${encodeURIComponent(id)}`;
+
+function subscribe(socket, id, extra = {}) {
+  return new Promise((resolve, reject) => socket.timeout(5_000).emit(ASSISTANT_CONVERSATION_SUBSCRIBE, {
+    subscriptionId: `view-${id}`, conversationId: id, targetSurfaceId: "home", hostSurfaceId: "home", ...extra
+  }, (error, response) => error ? reject(error) : resolve(response)));
+}
+
+async function until(changes, predicate) {
+  while (!predicate()) await once(changes, "change", { signal: AbortSignal.timeout(5_000) });
+}
+
+test("Fastify conversations await trusted authentication across HTTP and shared sockets without owning the runtime", { timeout: 20_000 }, async t => {
+  const trusted = { actor: { id: "42" }, applicationId: "host-application", policy: { owner: "server" } };
+  const sessions = new Map([["owner-session", trusted]]);
+  const authorizations = [];
+  const authenticated = [];
+  const ids = ["planning", "notes"];
+  const changes = new EventEmitter();
+  const packets = [];
+  let providerRequests = 0;
+  const runtime = createConversationRuntime({
+    storage: createMemoryConversationStorage(),
+    authorize(input) {
+      authorizations.push(input);
+      return input.context.actor?.id === trusted.actor.id && input.context.policy === trusted.policy &&
+        input.context.applicationId === trusted.applicationId && ids.includes(input.conversationId);
+    },
+    connections: { async resolve() {
+      return { providerId: "test", model: "test-model", sdkPackage: "@ai-sdk/openai-compatible",
+        apiKey: "test", baseURL: "http://test.invalid/v1" };
+    } },
+    // The existing subscriptions fixture's API SSE boundary, with completed
+    // replies: the real driver, runtime, HTTP actions and sockets run unchanged.
+    fetch: async () => {
+      const index = providerRequests++;
+      const chunks = [{ content: `Reply for ${ids[index]}.` }, {}].map((delta, chunk) => ({
+        id: `reply-${index}`, object: "chat.completion.chunk", created: 1, model: "test-model",
+        choices: [{ index: 0, delta, finish_reason: chunk ? "stop" : null }]
+      }));
+      return new Response(chunks.map(value => `data: ${JSON.stringify(value)}\n\n`).join(""),
+        { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const app = Fastify();
+  let socket;
+  t.after(async () => {
+    socket?.disconnect();
+    try { await app.close(); }
+    finally { await runtime.close(); }
+  });
+  const conversations = new Map();
+  for (const id of ids) conversations.set(id, await runtime.open({ id, context: trusted,
+    configuration: { integrationId: "test", systemPrompt: "Answer briefly." } }));
+  authorizations.length = 0;
+  await registerFastifyConversations(app, { runtime, config, env: {},
+    async authenticate(request) {
+      await Promise.resolve();
+      authenticated.push(request);
+      const session = request.cookies?.session || request.headers?.cookie?.match(/(?:^|;\s*)session=([^;]*)/u)?.[1];
+      return sessions.get(session) || null;
+    },
+    bootstrap({ request, context }) {
+      assert.equal(context, trusted);
+      assert.equal(request.headers.cookie, "session=owner-session");
+      return { host: { actorId: context.actor.id, applicationId: context.applicationId } };
+    }
+  });
+  const url = await app.listen({ host: "127.0.0.1", port: 0 });
+  let connections = 0;
+  app.server.on("connection", () => { connections++; });
+  const headers = { cookie: "session=owner-session", "x-jskit-surface": "home" };
+  for (const path of ["/api/bootstrap", route(ids[0])]) {
+    const denied = await app.inject({ method: "GET", url: path, headers: { "x-jskit-surface": "home" } });
+    assert.equal(denied.statusCode, 401, denied.body);
+  }
+  assert.equal(authorizations.length, 0, "missing authentication never reaches the caller's runtime");
+  const bootstrap = await app.inject({ method: "GET", url: "/api/bootstrap", headers });
+  assert.equal(bootstrap.statusCode, 200, bootstrap.body);
+  assert.deepEqual(bootstrap.json().host, { actorId: "42", applicationId: "host-application" });
+
+  socket = createSocketIoClient({ url, options: {
+    transports: ["websocket"], autoConnect: false, reconnection: false,
+    extraHeaders: { Cookie: "session=owner-session" }
+  } });
+  socket.on(ASSISTANT_CONVERSATION_EVENT, packet => { packets.push(packet); changes.emit("change"); });
+  const connected = once(socket, "connect", { signal: AbortSignal.timeout(5_000) });
+  socket.connect();
+  await connected;
+  const connectionId = socket.id;
+  const forged = { actor: { id: "forged" }, applicationId: "wire-application", policy: { owner: "wire" },
+    context: { actor: { id: "forged" }, applicationId: "wire-application", policy: { owner: "wire" } } };
+  for (const id of ids) {
+    const subscription = await subscribe(socket, id, { ...forged,
+      headers: { cookie: "session=forged-session" }, requestPolicy: "authenticated",
+      subscribeActionId: "wire.subscribe", room: "wire-room" });
+    assert.equal(subscription.ok, true, subscription.error);
+    assert.equal(subscription.state.id, id);
+    assert.deepEqual(subscription.state.conversationLog, []);
+    const forgedSend = await app.inject({ method: "POST", url: `${route(id)}/messages`, headers,
+      payload: { messageId: `question-${id}`, text: `Question for ${id}.`, ...forged } });
+    assert.equal(forgedSend.statusCode, 400, "HTTP schema rejects caller-supplied identity fields");
+    assert.equal(providerRequests, ids.indexOf(id), "rejected forged fields cannot dispatch a turn");
+    const sent = await app.inject({ method: "POST", url: `${route(id)}/messages`, headers,
+      payload: { messageId: `question-${id}`, text: `Question for ${id}.` } });
+    assert.equal(sent.statusCode, 202, sent.body);
+    const state = await conversations.get(id).wait();
+    assert.equal(state.status, "ready", state.error);
+    assert.equal(state.conversationLog.length, 1);
+    assert.equal(state.conversationLog[0].user.text, `Question for ${id}.`);
+    assert.equal(state.conversationLog[0].assistant.text, `Reply for ${id}.`);
+  }
+  await until(changes, () => ids.every(id => packets.some(packet => packet.subscriptionId === `view-${id}` &&
+    packet.event.type === "message" && packet.event.text === `Reply for ${id}.`)));
+  assert.equal(connections, 1);
+  assert.equal(socket.id, connectionId);
+  assert.ok(packets.every(packet => packet.subscriptionId === `view-${packet.conversationId}`));
+  for (const id of ids) {
+    assert.ok(authorizations.some(input => input.conversationId === id && input.operation === "subscribe"));
+    assert.ok(authorizations.some(input => input.conversationId === id && input.operation === "send"));
+  }
+  for (const { context } of authorizations) {
+    assert.deepEqual(context.actor, trusted.actor);
+    assert.equal(context.policy, trusted.policy);
+    assert.equal(context.applicationId, trusted.applicationId);
+  }
+  assert.ok(authenticated.some(request => request.method === "POST"));
+  assert.ok(authenticated.some(request => request.method === undefined), "socket requests also use the async authenticator");
+
+  sessions.delete("owner-session");
+  for (const path of ["/api/bootstrap", route(ids[0])]) {
+    const denied = await app.inject({ method: "GET", url: path, headers });
+    assert.equal(denied.statusCode, 401, denied.body);
+  }
+  const deniedSend = await app.inject({ method: "POST", url: `${route(ids[0])}/messages`, headers,
+    payload: { messageId: "revoked-attempt", text: "Never dispatch." } });
+  assert.equal(deniedSend.statusCode, 401, deniedSend.body);
+  const deniedSubscription = await subscribe(socket, ids[0], {
+    subscriptionId: "after-revocation", actor: trusted.actor, context: trusted,
+    headers: { cookie: "session=owner-session" }
+  });
+  assert.equal(deniedSubscription.ok, false);
+  assert.equal(deniedSubscription.status, 401);
+  assert.equal(providerRequests, 2, "wire credentials cannot dispatch after the host session is revoked");
+  assert.equal(socket.connected, true);
+  assert.equal(socket.id, connectionId);
+
+  const disconnected = once(socket, "disconnect", { signal: AbortSignal.timeout(5_000) });
+  await app.close();
+  await disconnected;
+  assert.equal(app.server.listening, false);
+  assert.equal(socket.connected, false);
+  const retained = await runtime.open({ id: ids[0], context: trusted });
+  assert.equal((await retained.read()).conversationLog[0].assistant.text, "Reply for planning.");
+  await retained.configure({ systemPrompt: "The caller still owns this runtime." });
+});

package/test/sqlConversationStorage.test.js

@@ -0,0 +1,205 @@
+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 { 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 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";
+
+async function fixture(t) {
+  const directory = await mkdtemp(path.join(tmpdir(), "assistant-sql-runtime-"));
+  const clients = [];
+  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) };
+  }
+  t.after(async () => { for (const client of clients) await client.destroy(); await rm(directory, { recursive: true, force: true }); });
+  const first = 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);
+  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: {} });
+  return { ...first, connect, conversation };
+}
+
+async function rows(db) {
+  return { conversations: await db("assistant_conversations").orderBy("id"), messages: await db("assistant_messages").orderBy("id") };
+}
+
+test("the existing runtime storage contract uses the original SQL rows and rolls back row, title, count and metadata together", async t => {
+  const f = await fixture(t);
+  const first = await f.conversation();
+  const other = await f.conversation("2");
+  const scopes = new Map([["actor-a:workspace-a:conversation-a", first.id], ["actor-b:workspace-a:conversation-a", other.id]]);
+  await verifyConversationStorageContract({
+    read: (scope, callback) => f.storage.read(scopes.get(scope), callback),
+    write: (scope, callback) => f.storage.write(scopes.get(scope), callback)
+  }, { runtime: true });
+  const saved = await rows(f.db);
+  assert.equal(saved.conversations[0].message_count, saved.messages.length);
+  assert.equal(saved.conversations[0].title, "First question");
+  assert.equal(saved.messages.filter(row => row.role === "assistant").length, 1);
+  assert.equal(saved.messages.find(row => row.role === "assistant").content_text, "Final answer");
+  assert.equal(saved.messages[0].client_message_sid, "request-a");
+
+  const failing = createSqlConversationStorage({ conversationsRepository: f.conversationsRepository,
+    messagesRepository: { ...f.messagesRepository, async create(input, options) {
+      const result = await f.messagesRepository.create(input, options);
+      if (input.contentText === "Fail after insert") throw new Error("forced-row-commit-failure");
+      return result;
+    } } });
+  await assert.rejects(failing.write(first.id, async transaction => {
+    await transaction.writeMetadata({ runtime: { uncommitted: true } });
+    await transaction.updateTurnMetadata("000001", { product: { uncommitted: true } });
+    await transaction.appendMessage(await transaction.nextTurnId(), {
+      role: "user", messageId: "failed-write", text: "Fail after insert", at: "2026-01-02T00:00:00Z"
+    });
+  }), /forced-row-commit-failure/);
+  assert.deepEqual(await rows(f.db), saved, "A failed SQL commit cannot leave an authored row, count, title or runtime metadata behind");
+  let invocations = 0;
+  await assert.rejects(f.storage.write(first.id, async () => {
+    invocations += 1;
+    throw Object.assign(new Error("Caller failure"), { code: "SQLITE_BUSY" });
+  }), /Caller failure/);
+  assert.equal(invocations, 1, "Lock acquisition retry must never replay a storage callback");
+});
+
+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 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)));
+  assert.equal(results.filter(Boolean).length, 1);
+  await Promise.all(transcripts.map((transcript, index) => transcript.writeConversationUserMessage(conversation.id,
+    { messageId: `next-${index}`, text: `Next ${index}` })));
+  const saved = await f.messagesRepository.listByConversationScope(conversation.id);
+  assert.deepEqual(saved.map(row => row.seq), [1, 2, 3]);
+  assert.equal(saved[0].clientMessageSid, input.messageId);
+  assert.equal((await f.conversationsRepository.findById(conversation.id)).messageCount, 3);
+  assert.equal((await second.storage.read(conversation.id, transaction => transaction.listTurnIds())).length, 3);
+});
+
+test("historical SQL projection preserves exact rows and blocks ambiguous history with read-only preflight", async t => {
+  const f = await fixture(t);
+  const conversation = await f.conversation();
+  const create = fields => f.messagesRepository.create({ conversationId: conversation.id, actorUserId: "1", role: "assistant", kind: "chat", ...fields });
+  const user = await create({ role: "user", clientMessageSid: "customer/123:review", contentText: "Existing question", metadata: { surfaceId: "assistant" } });
+  await create({ kind: "tool_call", contentText: '{"key":1}', metadata: { toolCallId: "lookup", tool: "inventory_lookup" } });
+  await create({ kind: "tool_result", contentText: '{"ok":true,"result":{"found":1}}', metadata: { toolCallId: "lookup", tool: "inventory_lookup", ok: true } });
+  await create({ contentText: "Existing answer" });
+  const before = await rows(f.db);
+  assert.deepEqual((await f.storage.preflight(conversation.id)).issues, []);
+  const turn = await f.storage.read(conversation.id, transaction => transaction.readTurn(user.id));
+  assert.equal(turn.user.messageId, "customer/123:review");
+  assert.equal(turn.assistant.text, "Existing answer");
+  assert.deepEqual(turn.metadata.applicationTools[0].result, { ok: true, result: { found: 1 } });
+  assert.deepEqual(await rows(f.db), before);
+  await f.storage.write(conversation.id, transaction => transaction.writeMetadata({ runtime: { inspection: "metadata only" } }));
+  assert.deepEqual((await rows(f.db)).messages, before.messages, "Runtime initialization does not backfill historical message rows");
+
+  const ambiguous = await f.conversation();
+  const first = await f.messagesRepository.create({ conversationId: ambiguous.id, role: "user", contentText: "First", clientMessageSid: "first" });
+  const next = await f.messagesRepository.create({ conversationId: ambiguous.id, role: "user", contentText: "Overlapping", clientMessageSid: "next" });
+  await f.messagesRepository.create({ conversationId: ambiguous.id, role: "assistant", contentText: "Unknown owner" });
+  const unchanged = await rows(f.db);
+  assert.deepEqual((await f.storage.preflight(ambiguous.id)).issues, [{ code: "overlapping_historical_turns", rowIds: [first.id, next.id] }]);
+  await assert.rejects(f.storage.write(ambiguous.id, transaction => transaction.writeMetadata({ runtime: {} })), /ambiguous historical SQL rows/);
+  assert.deepEqual(await rows(f.db), unchanged);
+
+  const interrupted = await f.conversation();
+  await f.messagesRepository.create({ conversationId: interrupted.id, role: "user", contentText: "Mutate", clientMessageSid: "mutate" });
+  const call = await f.messagesRepository.create({ conversationId: interrupted.id, role: "assistant", kind: "tool_call", contentText: "{}", metadata: { toolCallId: "unknown", tool: "mutate" } });
+  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 => {
+  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" });
+  await f.messagesRepository.create({ conversationId: conversation.id, role: "assistant", contentText: "Previous saved answer" });
+  await f.conversationsRepository.updateById(conversation.id, { messageCount: 2 });
+  const requests = [], resolved = [], events = [];
+  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) {
+      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" }] };
+      })();
+    } };
+  } };
+  const catalog = { limits: { maxToolArgumentBytes: 4096 },
+    resolveToolSet: () => ({ tools: [{ name: "inventory_lookup", parameters: { type: "object" } }] }),
+    toOpenAiToolSchema: tool => ({ type: "function", function: tool }),
+    async executeToolCall() {
+      executions += 1;
+      const calls = await f.db("assistant_messages").where({ conversation_id: conversation.id, kind: "tool_call" });
+      const results = await f.db("assistant_messages").where({ conversation_id: conversation.id, kind: "tool_result" });
+      assert.equal(calls.length, 1, "The original tool-call row is committed before the application effect");
+      assert.equal(results.length, 0);
+      assert.equal(JSON.parse(calls[0].metadata_json).conversationRuntime.status, "running");
+      return { ok: true, result: { found: 1 } };
+    } };
+  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),
+    assistantConfigService: { resolveSystemPrompt: async () => "Retained SQL instructions" },
+    appConfig: { surfaceDefinitions: { assistant: { enabled: true, requiresWorkspace: false } },
+      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" }] };
+  const options = { context: { actor: { id: "1" } }, streamWriter: Object.fromEntries(
+    ["sendMeta", "sendAssistantDelta", "sendAssistantMessage", "sendToolCall", "sendToolResult", "sendError", "sendDone"]
+      .map(name => [name, event => events.push({ name, event })])) };
+  assert.equal((await service.streamChat(input, options)).status, "completed");
+  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(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(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: [] } }]) {
+    await assert.rejects(runtime.open({ id: conversation.id,
+      context: { actor: { id: "1" }, surface: "assistant", assistantRequest: { conversation, workspace: null, history: [] }, ...change } }),
+    { code: "conversation_forbidden" });
+  }
+});

package/test/support/memoryAssistantRows.js

@@ -0,0 +1,51 @@
+/** Repository fixture for the original chat-service unit cases. The production
+ * SQL adapter and common runtime run unchanged over these transactional rows.
+ */
+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: [] };
+  let pending = Promise.resolve();
+  const read = options => options?.trx || state;
+  const conversationsRepository = {
+    async findById(value, options) { return value === id ? structuredClone(read(options).conversation) : null; },
+    async findByIdForActorScope(value, scope, options) {
+      const row = await this.findById(value, options);
+      return row && scope.actorUserId === row.createdByUserId && scope.surfaceId === row.surfaceId && scope.workspaceId === row.workspaceId ? row : null;
+    },
+    async updateById(value, patch, options) {
+      const target = read(options);
+      if (value !== id) return null;
+      Object.assign(target.conversation, structuredClone(patch));
+      return structuredClone(target.conversation);
+    },
+    transaction(operation) {
+      const next = pending.then(async () => {
+        const trx = structuredClone(state);
+        const value = await operation(trx);
+        state = trx;
+        messages.splice(0, messages.length, ...structuredClone(state.messages));
+        return value;
+      });
+      pending = next.catch(() => {});
+      return next;
+    }
+  };
+  const messagesRepository = {
+    async listByConversationScope(_id, _scope, { page, pageSize }, options) {
+      return structuredClone(read(options).messages.slice((page - 1) * pageSize, page * pageSize));
+    },
+    async create(payload, options) {
+      const rows = read(options).messages;
+      const row = { ...structuredClone(payload), id: String(rows.length + 1), seq: rows.length + 1,
+        clientMessageSid: payload.clientMessageSid || "", createdAt: payload.createdAt || new Date().toISOString() };
+      rows.push(row);
+      return structuredClone(row);
+    },
+    async updateById(value, patch, options) {
+      const row = read(options).messages.find(message => message.id === value);
+      Object.assign(row, structuredClone(patch));
+      return structuredClone(row);
+    }
+  };
+  return { conversationsRepository, messagesRepository };
+}

package/test/turnRequests.test.js

@@ -7,6 +7,8 @@ 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";
+import { createAssistantConversationRuntime } from "../src/server/createAssistantRuntime.js";
+import { createMemoryAssistantRows } from "./support/memoryAssistantRows.js";
 
 async function database(t) {
   const dir = await mkdtemp(path.join(tmpdir(), "assistant-requests-"));
@@ -45,7 +47,7 @@ test("migration preserves existing claims and database uniqueness arbitrates ind
 });
 
 function service(repository, { provider, transcript = [] } = {}) {
-  return createChatService({
+  const dependencies = {
     turnRequests: repository,
     aiClientFactory: { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "test", createChatCompletionStream: provider }) },
     transcriptService: {
@@ -53,13 +55,19 @@ function service(repository, { provider, transcript = [] } = {}) {
       async appendMessage(_surface, _id, message) { transcript.push(message); },
       async completeConversation() {}
     },
-    serviceToolCatalog: { resolveToolSet: () => ({ tools: [] }) },
+    serviceToolCatalog: { limits: { maxToolArgumentBytes: 64 * 1024 }, resolveToolSet: () => ({ tools: [] }),
+      toOpenAiToolSchema: tool => ({ type: "function", function: tool }) },
     assistantConfigService: { resolveSystemPrompt: async () => "Answer." },
     appConfig: {
       surfaceDefinitions: { assistant: { id: "assistant", enabled: true, requiresWorkspace: false, accessPolicyId: "public" } },
       assistantSurfaces: { assistant: { settingsSurfaceId: "assistant", configScope: "global" } }
     }
+  };
+  const conversationRuntime = createAssistantConversationRuntime({
+    ...createMemoryAssistantRows({ id: "100", messages: transcript }),
+    aiClientFactory: dependencies.aiClientFactory, toolCatalog: dependencies.serviceToolCatalog
   });
+  return createChatService({ ...dependencies, conversationRuntime });
 }
 
 function run(chat, input = request, { events = [], disconnectAfterCompletion = false } = {}) {
@@ -82,6 +90,7 @@ test("concurrent submissions, lost completion responses and a fresh service repl
     started.resolve();
     await waiting.promise;
     yield { choices: [{ delta: { content: "Completed once." } }] };
+    yield { choices: [{ delta: {}, finish_reason: "stop" }] };
   };
   const first = service(createRepository(db), { provider, transcript });
   const pending = run(first, request, { disconnectAfterCompletion: true });

package/src/shared/assistantResponseText.js

@@ -1,29 +0,0 @@
-const MAX_PROGRESS_ONLY_TEXT_CHARS = 600;
-
-const PROGRESS_SENTENCE_PATTERNS = Object.freeze([
-  /^(?:let me|i(?:'|’)ll|i will|i(?:'|’)m going to|i am going to)\s+(?:(?:first|now|quickly)\s+)*(?:analy[sz]e|call|check|confirm|do|execute|fetch|find|inspect|investigate|load|look up|open|prepare|query|read|retrieve|review|run|search|summarize|test|try|use|verify)\b/iu,
-  /^(?:analy[sz]ing|calling|checking|confirming|executing|fetching|finding|inspecting|investigating|loading|looking up|opening|preparing|querying|reading|retrieving|reviewing|running|searching|summarizing|testing|trying|using|verifying)\b/iu,
-  /^(?:one moment|please wait)\b/iu
-]);
-
-function isAssistantProgressOnlyText(value) {
-  const text = String(value || "")
-    .replace(/\s+/gu, " ")
-    .trim()
-    .replace(/^(?:okay|sure)[,;:!\s—-]+/iu, "");
-
-  if (!text || text.length > MAX_PROGRESS_ONLY_TEXT_CHARS) {
-    return false;
-  }
-
-  const sentences = text
-    .split(/(?<=[.!?…])\s+/u)
-    .map((sentence) => sentence.trim())
-    .filter(Boolean);
-
-  return sentences.length > 0 && sentences.every((sentence) =>
-    PROGRESS_SENTENCE_PATTERNS.some((pattern) => pattern.test(sentence))
-  );
-}
-
-export { isAssistantProgressOnlyText };