@jskit-ai/assistant-runtime 0.2.28 → 0.2.30

package/src/server/repositories/messagesRepository.js

@@ -1,29 +1,26 @@
-import { createWithTransaction, normalizeDbRecordId, runInTransaction } from "@jskit-ai/database-runtime/shared/repositoryOptions";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { passedOn } from "@jskit-ai/resource-core/shared/callOptions";
 import {
-  applyWorkspaceScope,
-  normalizeDbWorkspaceId,
   normalizeInputRecordId,
   parseJsonObject,
-  resolveInsertedId,
   stringifyJsonObject,
-  toIso
+  toIso,
+  toWrittenDateTime
 } from "./repositoryPersistenceUtils.js";
-import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
 
-function mapMessageRow(row = {}) {
+function mapMessageRecord(record = {}) {
   return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    conversationId: normalizeDbRecordId(row.conversation_id, { fallback: "" }),
-    workspaceId: normalizeDbWorkspaceId(row.workspace_id),
-    seq: Number(row.seq),
-    role: String(row.role || ""),
-    kind: String(row.kind || "chat"),
-    clientMessageSid: String(row.client_message_sid || ""),
-    actorUserId: row.actor_user_id == null ? null : normalizeDbRecordId(row.actor_user_id, { fallback: null }),
-    contentText: row.content_text == null ? null : String(row.content_text),
-    metadata: parseJsonObject(row.metadata_json),
-    createdAt: toIso(row.created_at)
+    id: normalizeRecordId(record.id, { fallback: "" }),
+    conversationId: normalizeRecordId(record.conversationId, { fallback: "" }),
+    workspaceId: normalizeInputRecordId(record.workspaceId),
+    seq: Number(record.seq),
+    role: String(record.role || ""),
+    kind: String(record.kind || "chat"),
+    clientMessageSid: String(record.clientMessageSid || ""),
+    actorUserId: record.actorUserId == null ? null : normalizeInputRecordId(record.actorUserId),
+    contentText: record.contentText == null ? null : String(record.contentText),
+    metadata: parseJsonObject(record.metadataJson),
+    createdAt: toIso(record.createdAt)
   };
 }
 
@@ -41,22 +38,43 @@ function normalizePagination(pagination = {}, { defaultPage = 1, defaultPageSize
   };
 }
 
-async function resolveNextSequence(client, conversationId) {
-  const row = await client(assistantRuntimeConfig.messagesTable)
-    .where({ conversation_id: conversationId })
-    .max({ maxSeq: "seq" })
-    .first();
-  const maxSeq = Number(row?.maxSeq || 0);
-  if (!Number.isInteger(maxSeq) || maxSeq < 0) {
-    return 1;
-  }
+// A conversation id list per query, so its "in" list stays well inside every database's limits.
+const CONVERSATION_IDS_PER_QUERY = 1000;
 
-  return maxSeq + 1;
+// Whether message a was written after b: the later createdAt, then the higher id.
+function isNewer(a, b) {
+  const byTime = Date.parse(toIso(a.createdAt)) - Date.parse(toIso(b.createdAt));
+  return byTime !== 0 ? byTime > 0 : BigInt(a.id) > BigInt(b.id);
 }
 
-/** @param {import("@jskit-ai/database-runtime/server/types").RuntimeKnex} knex */
-function createRepository(knex) {
-  const withTransaction = createWithTransaction(knex);
+/**
+ * A conversation's messages, on the assistantMessages table. Callers reach
+ * them by conversation id after checking that conversation's actor scope; a
+ * workspace's messages are read in that workspace, the rest in the system context.
+ * @param {object} dependencies
+ * @param {import("@jskit-ai/resource-runtime/server/types").ResourceHandle} dependencies.messages
+ * @param {import("@jskit-ai/resource-runtime/server/types").ResourceHandle} dependencies.conversations The
+ *   assistantConversations table's handle, for the conversations of one user.
+ * @param {(reason: string) => import("@jskit-ai/resource-runtime/server/types").SystemContext} dependencies.systemContext
+ */
+function createRepository({ messages, conversations, systemContext }) {
+  const messageContext = systemContext("messages reached by conversation id after the caller checked the conversation's actor scope");
+  const userContext = systemContext("the newest assistant message among one user's conversations, which the caller is entitled to read");
+
+  // A workspace's messages in that workspace; messages without one in the system context, filtered to none.
+  function scoped(workspaceId, options) {
+    return workspaceId
+      ? { filters: {}, options: { ...passedOn(options), context: messageContext.forWorkspace(workspaceId) } }
+      : { filters: { workspaceId: null }, options: { ...passedOn(options), context: messageContext } };
+  }
+
+  function withTransaction(options, work) {
+    return messages.withTransaction(options, work);
+  }
+
+  function transaction(work) {
+    return messages.withTransaction({}, work);
+  }
 
   async function findById(messageId, options = {}) {
     const normalizedMessageId = normalizeInputRecordId(messageId);
@@ -64,43 +82,43 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options.trx || knex;
-    const row = await client(assistantRuntimeConfig.messagesTable)
-      .where({ id: normalizedMessageId })
-      .first();
+    const record = await messages.get(normalizedMessageId, {}, { ...passedOn(options), context: messageContext, missing: "skip" });
+    return record ? mapMessageRecord(record) : null;
+  }
 
-    return row ? mapMessageRow(row) : null;
+  // The conversation's highest seq, across its workspaces, or 0.
+  async function highestSequence(conversationId, options) {
+    const [row] = await messages.aggregate({
+      measures: { maxSeq: { max: "seq" } },
+      filters: { conversationId }
+    }, { ...passedOn(options), context: messageContext });
+    const maxSeq = Number(row?.maxSeq || 0);
+    return Number.isInteger(maxSeq) && maxSeq > 0 ? maxSeq : 0;
   }
 
   async function create(payload = {}, options = {}) {
-    const client = options.trx || knex;
     const conversationId = normalizeInputRecordId(payload.conversationId);
     if (!conversationId) {
       throw new TypeError("messagesRepository.create requires conversationId.");
     }
 
     const providedSeq = Number(payload.seq);
-    const seq = Number.isInteger(providedSeq) && providedSeq > 0 ? providedSeq : (await resolveNextSequence(client, conversationId));
-    const insertResult = await client(assistantRuntimeConfig.messagesTable).insert({
-      conversation_id: conversationId,
-      workspace_id: normalizeInputRecordId(payload.workspaceId),
+    const seq = Number.isInteger(providedSeq) && providedSeq > 0 ? providedSeq : (await highestSequence(conversationId, options)) + 1;
+    const workspaceId = normalizeInputRecordId(payload.workspaceId);
+    const created = await messages.create({
+      conversationId,
+      workspaceId,
       seq,
       role: normalizeText(payload.role).toLowerCase(),
       kind: normalizeText(payload.kind).toLowerCase() || "chat",
-      client_message_sid: normalizeText(payload.clientMessageSid),
-      actor_user_id: normalizeInputRecordId(payload.actorUserId),
-      content_text: payload.contentText == null ? null : String(payload.contentText),
-      metadata_json: stringifyJsonObject(payload.metadata),
-      created_at: payload.createdAt ? new Date(payload.createdAt) : new Date()
-    });
-    const id = resolveInsertedId(insertResult);
-    if (!id) {
-      throw new Error("messagesRepository.create could not resolve inserted id.");
-    }
-
-    return findById(id, {
-      trx: client
-    });
+      clientMessageSid: normalizeText(payload.clientMessageSid),
+      actorUserId: normalizeInputRecordId(payload.actorUserId),
+      contentText: payload.contentText == null ? null : String(payload.contentText),
+      metadataJson: stringifyJsonObject(payload.metadata),
+      createdAt: toWrittenDateTime(payload.createdAt)
+    }, scoped(workspaceId, options).options);
+
+    return mapMessageRecord(created);
   }
 
   async function countByConversationScope(conversationId, { workspaceId = null } = {}, options = {}) {
@@ -109,12 +127,11 @@ function createRepository(knex) {
       return 0;
     }
 
-    const client = options.trx || knex;
-    const query = client(assistantRuntimeConfig.messagesTable).where({
-      conversation_id: normalizedConversationId
-    });
-    applyWorkspaceScope(query, "workspace_id", workspaceId);
-    const row = await query.count({ total: "*" }).first();
+    const scope = scoped(normalizeInputRecordId(workspaceId), options);
+    const [row] = await messages.aggregate({
+      measures: { total: { count: "*" } },
+      filters: { ...scope.filters, conversationId: normalizedConversationId }
+    }, scope.options);
 
     const total = Number(row?.total || 0);
     return Number.isFinite(total) && total > 0 ? total : 0;
@@ -123,45 +140,76 @@ function createRepository(knex) {
   async function updateById(messageId, patch = {}, options = {}) {
     const id = normalizeInputRecordId(messageId);
     if (!id) return null;
-    const client = options.trx || knex;
-    const update = {};
-    if (Object.hasOwn(patch, "contentText")) update.content_text = patch.contentText == null ? null : String(patch.contentText);
-    if (Object.hasOwn(patch, "metadata")) update.metadata_json = stringifyJsonObject(patch.metadata);
-    if (Object.keys(update).length) await client(assistantRuntimeConfig.messagesTable).where({ id }).update(update);
-    return findById(id, { trx: client });
+    const changes = {};
+    if (Object.hasOwn(patch, "contentText")) changes.contentText = patch.contentText == null ? null : String(patch.contentText);
+    if (Object.hasOwn(patch, "metadata")) changes.metadataJson = stringifyJsonObject(patch.metadata);
+    if (Object.keys(changes).length) {
+      await messages.patch(id, changes, { ...passedOn(options), context: messageContext, missing: "skip", returning: "none" });
+    }
+    return findById(id, options);
   }
 
+  // One numbered page of the conversation's messages in seq order, in one statement.
   async function listByConversationScope(conversationId, { workspaceId = null } = {}, pagination = {}, options = {}) {
     const normalizedConversationId = normalizeInputRecordId(conversationId);
     if (!normalizedConversationId) {
       return [];
     }
 
-    const client = options.trx || knex;
     const { page, pageSize } = normalizePagination(pagination);
-    const offset = (page - 1) * pageSize;
-
-    const query = client(assistantRuntimeConfig.messagesTable).where({
-      conversation_id: normalizedConversationId
-    });
-    applyWorkspaceScope(query, "workspace_id", workspaceId);
-    const rows = await query
-      .orderBy("seq", "asc")
-      .orderBy("id", "asc")
-      .limit(pageSize)
-      .offset(offset);
-
-    return rows.map(mapMessageRow);
+    const scope = scoped(normalizeInputRecordId(workspaceId), options);
+    const { records } = await messages.query({
+      filters: { ...scope.filters, conversationId: normalizedConversationId },
+      sort: ["seq", "id"],
+      page: { size: pageSize, number: page }
+    }, scope.options);
+    return records.map(mapMessageRecord);
+  }
+
+  /**
+   * The newest assistant message (the latest createdAt, then the highest id)
+   * in any of one user's conversations, in every workspace and surface, or
+   * null; with `kind`, the newest of that kind, such as "chat" for a reply.
+   * Two reads for a user with up to 1,000 conversations: their ids, then the
+   * newest message among them.
+   * @param {unknown} userId
+   * @param {{ kind?: string }} [criteria]
+   * @param {{ context?: object | null, trx?: object | null }} [options]
+   */
+  async function findNewestAssistantByUserId(userId, { kind = "" } = {}, options = {}) {
+    const normalizedUserId = normalizeInputRecordId(userId);
+    if (!normalizedUserId) {
+      return null;
+    }
+
+    const owned = await conversations.queryAll(
+      { filters: { userId: normalizedUserId }, fields: ["userId"] },
+      { ...passedOn(options), context: userContext.forUser(normalizedUserId) }
+    );
+    const conversationIds = owned.map((conversation) => normalizeRecordId(conversation.id, { fallback: "" })).filter(Boolean);
+    const normalizedKind = normalizeText(kind).toLowerCase();
+    let newest = null;
+    for (let start = 0; start < conversationIds.length; start += CONVERSATION_IDS_PER_QUERY) {
+      const { records: [candidate] } = await messages.query({
+        filters: {
+          conversationIds: conversationIds.slice(start, start + CONVERSATION_IDS_PER_QUERY),
+          role: "assistant",
+          ...(normalizedKind ? { kind: normalizedKind } : {})
+        },
+        sort: ["-createdAt", "-id"],
+        page: { size: 1 }
+      }, { ...passedOn(options), context: messageContext });
+      if (candidate && (!newest || isNewer(candidate, newest))) {
+        newest = candidate;
+      }
+    }
+    return newest ? mapMessageRecord(newest) : null;
   }
 
   async function lastSequence(conversationId, options = {}) {
     const normalizedConversationId = normalizeInputRecordId(conversationId);
     if (!normalizedConversationId) return 0;
-    return (await resolveNextSequence(options.trx || knex, normalizedConversationId)) - 1;
-  }
-
-  async function transaction(callback) {
-    return runInTransaction(knex, callback);
+    return highestSequence(normalizedConversationId, options);
   }
 
   return Object.freeze({
@@ -171,6 +219,7 @@ function createRepository(knex) {
     updateById,
     countByConversationScope,
     listByConversationScope,
+    findNewestAssistantByUserId,
     lastSequence,
     transaction
   });

package/src/server/repositories/repositoryPersistenceUtils.js

@@ -1,26 +1,12 @@
-import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
-import { normalizeDbRecordId } from "@jskit-ai/database-runtime/shared/repositoryOptions";
 import { normalizeRecordId } from "@jskit-ai/kernel/shared/support/normalize";
 import { parseJsonObject } from "@jskit-ai/assistant-core/shared";
 
-function normalizeDbWorkspaceId(value) {
-  return normalizeDbRecordId(value, { fallback: null });
-}
-
+/** @param {unknown} value */
 function normalizeInputRecordId(value) {
   return normalizeRecordId(value, { fallback: null });
 }
 
-function applyWorkspaceScope(query, columnName, workspaceId) {
-  const normalizedWorkspaceId = normalizeInputRecordId(workspaceId);
-  if (normalizedWorkspaceId) {
-    return query.where(columnName, normalizedWorkspaceId);
-  }
-
-  return query.whereNull(columnName);
-}
-
-
+/** @param {unknown} value */
 function stringifyJsonObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return null;
@@ -29,12 +15,13 @@ function stringifyJsonObject(value) {
   return JSON.stringify(value);
 }
 
+/** @param {unknown} value */
 function toIso(value) {
   if (!value) {
     return "";
   }
 
-  const date = value instanceof Date ? value : new Date(value);
+  const date = value instanceof Date ? value : new Date(/** @type {string | number} */ (value));
   if (Number.isNaN(date.getTime())) {
     return "";
   }
@@ -42,16 +29,18 @@ function toIso(value) {
   return date.toISOString();
 }
 
-function resolveInsertedId(insertResult) {
-  return resolveInsertedRecordId(insertResult, { fallback: "" }) || "";
+/**
+ * A date-time a repository writes: the caller's value as ISO text, or now.
+ * @param {unknown} [value]
+ */
+function toWrittenDateTime(value = null) {
+  return (value ? new Date(/** @type {string | number | Date} */ (value)) : new Date()).toISOString();
 }
 
 export {
-  applyWorkspaceScope,
-  normalizeDbWorkspaceId,
   normalizeInputRecordId,
   parseJsonObject,
   stringifyJsonObject,
   toIso,
-  resolveInsertedId
+  toWrittenDateTime
 };

package/src/server/repositories/turnRequestsRepository.js

@@ -1,33 +1,67 @@
 import { randomUUID } from "node:crypto";
-import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
+import { toWrittenDateTime } from "./repositoryPersistenceUtils.js";
 
-/** @param {import("@jskit-ai/database-runtime/server/types").RuntimeKnex} knex */
-function createRepository(knex) {
-  const table = assistantRuntimeConfig.turnRequestsTable;
+function scopeKey(scope) {
+  return JSON.stringify([scope.surfaceId, scope.workspaceId]);
+}
 
-  function key(scope, messageId) {
-    return { actor_user_id: scope.actorUserId, scope_key: JSON.stringify([scope.surfaceId, scope.workspaceId]), message_sid: messageId };
-  }
+function mapTurnRequestRecord(record) {
+  return {
+    id: record.id,
+    token: record.claimToken,
+    request: JSON.parse(record.requestJson),
+    response: record.responseJson ? JSON.parse(record.responseJson) : null,
+    status: record.status
+  };
+}
+
+/**
+ * The receipt of each chat request, on the assistantTurnRequests table: its
+ * actor claims and reads it in that actor's user context; the claim that
+ * recorded it settles it.
+ * @param {object} dependencies
+ * @param {import("@jskit-ai/resource-runtime/server/types").ResourceHandle} dependencies.turnRequests
+ * @param {(reason: string) => import("@jskit-ai/resource-runtime/server/types").SystemContext} dependencies.systemContext
+ */
+function createRepository({ turnRequests, systemContext }) {
+  const receiptContext = systemContext("a request receipt is settled by the claim that recorded it, after its actor's request was checked");
 
   async function find(scope, messageId) {
-    const row = await knex(table).where(key(scope, messageId)).first();
-    return row ? { id: row.id, token: row.claim_token, request: JSON.parse(row.request_json),
-      response: row.response_json ? JSON.parse(row.response_json) : null, status: row.status } : null;
+    const { records } = await turnRequests.query({
+      filters: { scopeKey: scopeKey(scope), messageSid: messageId },
+      page: { size: 1 }
+    }, { context: receiptContext.forUser(scope.actorUserId) });
+    return records[0] ? mapTurnRequestRecord(records[0]) : null;
   }
 
   async function claim(scope, request) {
     const token = randomUUID();
-    await knex(table).insert({ ...key(scope, request.messageId), claim_token: token, request_json: JSON.stringify(request) })
-      .onConflict(["actor_user_id", "scope_key", "message_sid"]).ignore();
+    await turnRequests.createMany([{
+      scopeKey: scopeKey(scope),
+      messageSid: request.messageId,
+      claimToken: token,
+      requestJson: JSON.stringify(request)
+    }], {
+      context: receiptContext.forUser(scope.actorUserId),
+      onConflict: { keys: ["userId", "scopeKey", "messageSid"], action: "ignore" }
+    });
     const record = await find(scope, request.messageId);
     if (!record) throw new Error("Assistant request could not be recorded.");
     return { ...record, acquired: record.token === token };
   }
 
-  async function update(claim, response, status = "running") {
-    const changed = await knex(table).where({ id: claim.id, claim_token: claim.token, status: "running" })
-      .update({ response_json: JSON.stringify(response), status, updated_at: new Date() });
-    if (!changed) throw new Error("Assistant request ownership was lost.");
+  async function update(claimed, response, status = "running") {
+    const changed = await turnRequests.patch(claimed.id, {
+      responseJson: JSON.stringify(response),
+      status,
+      updatedAt: toWrittenDateTime()
+    }, {
+      context: receiptContext,
+      onlyIf: { claimToken: claimed.token, status: "running" },
+      missing: "skip",
+      returning: "id"
+    });
+    if (changed === null) throw new Error("Assistant request ownership was lost.");
   }
 
   return Object.freeze({

package/src/server/services/assistantConfigService.js

@@ -8,6 +8,8 @@ import { resolveAssistantServerConfig, resolveAssistantServerConfigMap } from ".
 
 const WORKSPACE_SETTINGS_UPDATE_POLICY = Object.freeze({ require: "all", permissions: Object.freeze(["workspace.settings.update"]) });
 const ASSISTANT_SETTINGS_UPDATE_POLICY = Object.freeze({ require: "all", permissions: Object.freeze(["assistant.settings.update"]) });
+// The statuses of an access check's refusal (not signed in, not allowed), as against a failure.
+const ACCESS_REFUSED_STATUSES = Object.freeze([401, 403]);
 
 /**
  * An assistant surface's saved settings: who may read and change them, and the
@@ -111,6 +113,25 @@ function createService({
     });
   }
 
+  /**
+   * Whether the context may change a surface's settings: the check updateSettings makes, answered instead of thrown,
+   * so the settings screen offers Save only to the people the server lets save.
+   */
+  async function canUpdateSettings(input = {}, options = {}) {
+    const assistantSurface = requireAssistantSurface(appConfig, input.targetSurfaceId);
+    try {
+      await requireSettingsAccess(assistantSurface, options.context, {
+        mode: "write"
+      });
+      return true;
+    } catch (error) {
+      if (ACCESS_REFUSED_STATUSES.includes(Number(error?.status))) {
+        return false;
+      }
+      throw error;
+    }
+  }
+
   async function updateSettings(input = {}, patch = {}, options = {}) {
     const assistantSurface = requireAssistantSurface(appConfig, input.targetSurfaceId);
     await requireSettingsAccess(assistantSurface, options.context, {
@@ -145,6 +166,7 @@ function createService({
 
   return Object.freeze({
     getSettings,
+    canUpdateSettings,
     updateSettings,
     resolveSystemPrompt
   });

package/src/server/services/chatService.js

@@ -1,6 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
 import { resolveActor } from "@jskit-ai/kernel/server/actions/actionContributorHelpers";
-import { AppError, createValidationError } from "@jskit-ai/kernel/server/runtime";
+import { AppError, createValidationError, hideDatabaseError } from "@jskit-ai/kernel/server/runtime";
+import { silentLogger } from "@jskit-ai/kernel/server/runtime/logger";
 import { normalizeObject, normalizeRecordId, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { resolveWorkspaceSlug } from "@jskit-ai/assistant-core/server";
 import { conversationAttachmentIds } from "@jskit-ai/assistant-core/server/conversation";
@@ -156,6 +157,7 @@ function buildAssistantActionContext(context = {}, assistantSurface = {}) {
  * @param {PersonContextPrompt} dependencies.personContextPrompt
  * @param {Record<string, any>} dependencies.appConfig
  * @param {WorkspaceScopeSupport | null} [dependencies.workspaceScopeSupport]
+ * @param {import("@jskit-ai/kernel/server/types").RuntimeLogger} [dependencies.logger]
  */
 function createChatService({
   conversationRuntime,
@@ -167,7 +169,8 @@ function createChatService({
   assistantConfigService,
   personContextPrompt,
   appConfig,
-  workspaceScopeSupport
+  workspaceScopeSupport,
+  logger = silentLogger
 }) {
   function resolveRuntimeWorkspace(assistantSurface, context = {}, input = {}) {
     if (assistantSurface?.runtimeSurfaceRequiresWorkspace !== true) {
@@ -279,14 +282,16 @@ function createChatService({
     let result;
     try {
       result = await executeTurn();
-    } catch (error) {
+    } catch (thrown) {
+      // A database error is saved, so replayed, only as its stand-in; the route answers and logs the error itself.
+      const error = hideDatabaseError(thrown);
       response.failure = { message: String(error?.message || "Assistant request failed."),
         status: errorStatus(error),
         ...(error instanceof AppError ? { code: error.code,
           ...(exposedAppErrorDetails(error) ? { details: error.details } : {}) } : {}),
         ...savedMessageFields(error) };
       await turnRequests.update(claim, response, "failed");
-      throw error;
+      throw thrown;
     }
     await turnRequests.update(claim, response, result.status);
     if (response.done) output.sendDone(response.done);
@@ -413,10 +418,13 @@ function createChatService({
           streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text });
           streamWriter.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: source.messageId, status: "completed" });
           return { conversationId, messageId: source.messageId, status: "completed" };
-        } catch (error) {
-          const aborted = isAbortError(error) || options.abortSignal?.aborted;
+        } catch (thrown) {
+          const aborted = isAbortError(thrown) || options.abortSignal?.aborted;
           const status = aborted ? "aborted" : "failed";
-          if (!streamed) throw error;
+          if (!streamed) throw thrown;
+          // A database error streams only as its stand-in (a generic 409 or 500), and its detail goes to the log.
+          const error = hideDatabaseError(thrown);
+          if (error !== thrown) logger.error({ err: thrown }, "Assistant turn failed on a database error.");
           await transcriptService.completeConversation(assistantSurface, conversationId, { status }, { context: assistantContext, workspace });
           streamWriter.sendError({ type: ASSISTANT_STREAM_EVENT_TYPES.ERROR, messageId: source.messageId,
             code: aborted ? "assistant_stream_aborted" : String(error?.code || "assistant_stream_failed"),

package/src/server/services/transcriptService.js

@@ -162,12 +162,12 @@ function createTranscriptService({ conversationsRepository, messagesRepository }
       required: true
     });
     const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, options.workspace || context.workspace);
-    return conversationsRepository.transaction(async trx => {
+    return conversationsRepository.transaction(async txOptions => {
       const existing = await conversationsRepository.findByIdForActorScope(normalizedConversationId, {
         workspaceId,
         actorUserId,
         surfaceId: resolvedAssistantSurface.targetSurfaceId
-      }, { trx, forUpdate: true });
+      }, { ...txOptions, forUpdate: true });
       if (!existing) {
         throw new AppError(404, "Conversation not found.", { code: "assistant.runtime.conversation.notFound" });
       }
@@ -181,7 +181,7 @@ function createTranscriptService({ conversationsRepository, messagesRepository }
           ...normalizeObject(existing.metadata),
           ...normalizeObject(source.metadata)
         }
-      }, { trx });
+      }, txOptions);
     });
   }