@jskit-ai/assistant-runtime 0.1.192 → 0.1.194

package/src/server/services/transcriptService.js

@@ -152,43 +152,45 @@ function createTranscriptService({ conversationsRepository, messagesRepository }
     const context = normalizeObject(options.context);
     const actorUserId = normalizeRecordId(source.actorUserId, { fallback: null }) || resolveActorUserId(context.actor);
     const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, options.workspace || context.workspace);
-    const conversation = await conversationsRepository.findByIdForActorScope(normalizedConversationId, {
-      workspaceId,
-      actorUserId,
-      surfaceId: resolvedAssistantSurface.targetSurfaceId
-    });
-    if (!conversation) {
-      throw new AppError(404, "Conversation not found.");
-    }
-
-    const createdMessage = await messagesRepository.create({
-      conversationId: normalizedConversationId,
-      workspaceId: conversation.workspaceId,
-      role: normalizeText(source.role).toLowerCase(),
-      kind: normalizeText(source.kind).toLowerCase() || "chat",
-      clientMessageSid: normalizeText(source.clientMessageSid),
-      actorUserId,
-      contentText: source.contentText == null ? null : String(source.contentText),
-      metadata: normalizeObject(source.metadata)
-    });
-
-    await conversationsRepository.incrementMessageCount(normalizedConversationId, 1);
+    return conversationsRepository.transaction(async trx => {
+      const conversation = await conversationsRepository.findByIdForActorScope(normalizedConversationId, {
+        workspaceId,
+        actorUserId,
+        surfaceId: resolvedAssistantSurface.targetSurfaceId
+      }, { trx, forUpdate: true });
+      if (!conversation) {
+        throw new AppError(404, "Conversation not found.");
+      }
 
-    const messageRole = normalizeText(source.role).toLowerCase();
-    const messageKind = normalizeText(source.kind).toLowerCase() || "chat";
-    if (messageRole === "user" && messageKind === "chat" && isDefaultConversationTitle(conversation.title)) {
-      const derivedTitle = deriveConversationTitleFromMessage(source.contentText);
-      if (derivedTitle) {
-        await conversationsRepository.updateById(normalizedConversationId, {
-          title: derivedTitle
-        });
+      const createdMessage = await messagesRepository.create({
+        conversationId: normalizedConversationId,
+        workspaceId: conversation.workspaceId,
+        role: normalizeText(source.role).toLowerCase(),
+        kind: normalizeText(source.kind).toLowerCase() || "chat",
+        clientMessageSid: normalizeText(source.clientMessageSid),
+        actorUserId,
+        contentText: source.contentText == null ? null : String(source.contentText),
+        metadata: normalizeObject(source.metadata)
+      }, { trx });
+
+      await conversationsRepository.updateById(normalizedConversationId, { messageCount: conversation.messageCount + 1 }, { trx });
+
+      const messageRole = normalizeText(source.role).toLowerCase();
+      const messageKind = normalizeText(source.kind).toLowerCase() || "chat";
+      if (messageRole === "user" && messageKind === "chat" && isDefaultConversationTitle(conversation.title)) {
+        const derivedTitle = deriveConversationTitleFromMessage(source.contentText);
+        if (derivedTitle) {
+          await conversationsRepository.updateById(normalizedConversationId, {
+            title: derivedTitle
+          }, { trx });
+        }
       }
-    }
 
-    return {
-      conversationId: normalizedConversationId,
-      message: createdMessage
-    };
+      return {
+        conversationId: normalizedConversationId,
+        message: createdMessage
+      };
+    });
   }
 
   async function completeConversation(assistantSurface, conversationId, payload = {}, options = {}) {
@@ -204,24 +206,26 @@ function createTranscriptService({ conversationsRepository, messagesRepository }
       required: true
     });
     const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, options.workspace || context.workspace);
-    const existing = await conversationsRepository.findByIdForActorScope(normalizedConversationId, {
-      workspaceId,
-      actorUserId,
-      surfaceId: resolvedAssistantSurface.targetSurfaceId
-    });
-    if (!existing) {
-      throw new AppError(404, "Conversation not found.");
-    }
-
-    return conversationsRepository.updateById(normalizedConversationId, {
-      status: normalizeConversationStatus(source.status, {
-        fallback: "completed"
-      }),
-      endedAt: source.endedAt || new Date(),
-      metadata: {
-        ...normalizeObject(existing.metadata),
-        ...normalizeObject(source.metadata)
+    return conversationsRepository.transaction(async trx => {
+      const existing = await conversationsRepository.findByIdForActorScope(normalizedConversationId, {
+        workspaceId,
+        actorUserId,
+        surfaceId: resolvedAssistantSurface.targetSurfaceId
+      }, { trx, forUpdate: true });
+      if (!existing) {
+        throw new AppError(404, "Conversation not found.");
       }
+
+      return conversationsRepository.updateById(normalizedConversationId, {
+        status: normalizeConversationStatus(source.status, {
+          fallback: "completed"
+        }),
+        endedAt: source.endedAt || new Date(),
+        metadata: {
+          ...normalizeObject(existing.metadata),
+          ...normalizeObject(source.metadata)
+        }
+      }, { trx });
     });
   }
 
@@ -326,4 +330,4 @@ function createTranscriptService({ conversationsRepository, messagesRepository }
   });
 }
 
-export { createTranscriptService };
+export { createTranscriptService, deriveConversationTitleFromMessage, isDefaultConversationTitle };

package/src/server/sqlConversationStorage.js

@@ -0,0 +1,192 @@
+import { isDeepStrictEqual } from "node:util";
+import { setTimeout as delay } from "node:timers/promises";
+import { AppError } from "@jskit-ai/kernel/server/runtime";
+import { createConversationStorage } from "@jskit-ai/assistant-core/server/conversation";
+import { deriveConversationTitleFromMessage, isDefaultConversationTitle } from "./services/transcriptService.js";
+
+const roles = new Set(["user", "system", "assistant", "commentary", "thinking"]);
+const authored = row => row.kind === "chat" && ["user", "system"].includes(row.role);
+const rowLink = row => row.metadata?.conversationRuntime;
+
+function messageFromRow(row) {
+  const { turnId: _turnId, turnMetadata: _turnMetadata, ...fields } = rowLink(row) || {};
+  return { ...fields, role: row.role, text: row.contentText || "", at: row.createdAt,
+    messageId: authored(row) ? row.clientMessageSid : fields.messageId || "",
+    ...(row.metadata?.attachments ? { attachments: structuredClone(row.metadata.attachments) } : {}) };
+}
+
+/** Read-only projection. Historical ambiguities are reported, never repaired. */
+function inspectSqlConversationRows(conversation, rows) {
+  const turns = new Map();
+  const groups = new Map();
+  const issues = [];
+  const receipts = new Map();
+  let previousLegacy = null;
+  const issue = (code, ...entries) => issues.push({ code, rowIds: entries.filter(Boolean).map(row => row.id) });
+  for (const row of rows) {
+    const link = rowLink(row);
+    if (link !== undefined && (!link || typeof link.turnId !== "string" || !link.turnId)) {
+      issue("invalid_turn_link", row);
+      continue;
+    }
+    let id = link?.turnId;
+    if (authored(row)) {
+      if (!link && previousLegacy) issue("overlapping_historical_turns", previousLegacy, row);
+      id ||= row.id;
+      if (groups.has(id)) { issue("duplicate_turn", groups.get(id).anchor, row); continue; }
+      if (row.clientMessageSid && receipts.has(row.clientMessageSid)) issue("duplicate_message_receipt", receipts.get(row.clientMessageSid), row);
+      if (row.clientMessageSid) receipts.set(row.clientMessageSid, row);
+      groups.set(id, { anchor: row, messages: [], calls: new Map(), results: new Map(), explicit: Boolean(link) });
+      turns.set(id, { messages: [], ...(link?.turnMetadata ? { metadata: structuredClone(link.turnMetadata) } : {}) });
+      previousLegacy = link ? null : row;
+    } else if (!id) {
+      id = previousLegacy?.id;
+    }
+    const group = groups.get(id);
+    if (!group) { issue("orphan_output", row); continue; }
+    if (roles.has(row.role) && (row.kind === "chat" || link && row.kind === row.role)) {
+      if (row.role === "assistant" && group.messages.some(entry => entry.role === "assistant")) {
+        issue("multiple_historical_answers", group.anchor, row);
+        continue;
+      }
+      group.messages.push(row);
+      turns.get(id).messages.push(messageFromRow(row));
+      if (!link && row.role === "assistant") previousLegacy = null;
+    } else if (["tool_call", "tool_result"].includes(row.kind)) {
+      const callId = row.metadata?.toolCallId;
+      const target = row.kind === "tool_call" ? group.calls : group.results;
+      if (typeof callId !== "string" || !callId || target.has(callId)) issue("ambiguous_tool_identity", target.get(callId), row);
+      else target.set(callId, row);
+    } else issue("unsupported_message_shape", row);
+  }
+  for (const [id, group] of groups) {
+    const tools = [];
+    for (const [callId, row] of group.calls) {
+      const resultRow = group.results.get(callId);
+      let result;
+      if (resultRow) {
+        try { result = JSON.parse(resultRow.contentText); } catch { issue("invalid_tool_result", resultRow); }
+        if (!result || typeof result.ok !== "boolean" || resultRow.metadata.tool !== row.metadata.tool) {
+          issue("conflicting_tool_result", row, resultRow);
+        }
+      } else if (!group.explicit) issue("unconfirmed_historical_tool", row);
+      tools.push({ id: callId, name: row.metadata.tool, arguments: row.contentText || "", at: row.createdAt,
+        status: rowLink(row)?.status || (result ? !result.ok && result.error?.status >= 500 ? "unknown" : "complete" : "running"),
+        ...(result ? { result } : {}) });
+    }
+    for (const [callId, row] of group.results) if (!group.calls.has(callId)) issue("orphan_tool_result", row);
+    if (tools.length) turns.get(id).metadata = { ...turns.get(id).metadata, applicationTools: tools };
+  }
+  return { record: { metadata: structuredClone(conversation.metadata || {}), turns }, groups, issues };
+}
+
+function requireUnambiguous(projection) {
+  if (!projection.issues.length) return;
+  throw new AppError(409, "This conversation has ambiguous historical SQL rows. Inspect the reported rows offline before using the common runtime; no history was changed.", {
+    code: "assistant_history_inspection_required", details: { issues: projection.issues }
+  });
+}
+
+/** Existing SQL rows remain authoritative. Core supplies the transaction methods;
+ * the database owns locking, sequence allocation and commit/rollback together.
+ */
+function createSqlConversationStorage({ conversationsRepository, messagesRepository }) {
+  async function load(id, trx, write = false) {
+    const conversation = await conversationsRepository.findById(id, { trx, forUpdate: write });
+    if (!conversation) throw new AppError(404, "Conversation not found.");
+    const rows = [];
+    for (let page = 1; ; page += 1) {
+      const batch = await messagesRepository.listByConversationScope(id, { workspaceId: conversation.workspaceId }, { page, pageSize: 500 }, { trx });
+      rows.push(...batch);
+      if (batch.length < 500) break;
+    }
+    return { conversation, rows, projection: inspectSqlConversationRows(conversation, rows) };
+  }
+
+  async function save(id, loaded, record, trx) {
+    const { conversation, projection } = loaded;
+    let added = 0;
+    let title = conversation.title;
+    const persist = async (previous, fields) => {
+      if (previous) {
+        if (previous.contentText !== fields.contentText || !isDeepStrictEqual(previous.metadata, fields.metadata)) {
+          await messagesRepository.updateById(previous.id, { contentText: fields.contentText, metadata: fields.metadata }, { trx });
+        }
+      } else {
+        await messagesRepository.create({ conversationId: id, workspaceId: conversation.workspaceId,
+          actorUserId: conversation.createdByUserId, ...fields }, { trx });
+        added += 1;
+      }
+    };
+    for (const [turnId, turn] of record.turns) {
+      const original = projection.record.turns.get(turnId);
+      if (isDeepStrictEqual(turn, original)) continue;
+      const group = projection.groups.get(turnId);
+      const { applicationTools = [], ...turnMetadata } = turn.metadata || {};
+      for (const message of turn.messages) {
+        const previous = group?.messages.find(row => row.role === message.role &&
+          (message.role === "assistant" || messageFromRow(row).messageId === message.messageId && row.createdAt === message.at));
+        const { role, text, at, attachments, messageId, ...fields } = message;
+        const isAuthored = ["user", "system"].includes(role);
+        const metadata = { ...previous?.metadata, ...(isAuthored ? { surfaceId: conversation.surfaceId } : {}), ...(attachments ? { attachments } : {}),
+          conversationRuntime: { turnId, ...fields, ...(!isAuthored && messageId ? { messageId } : {}),
+            ...(isAuthored ? { turnMetadata } : {}) } };
+        await persist(previous, { role, kind: ["commentary", "thinking"].includes(role) ? role : "chat",
+          clientMessageSid: isAuthored ? messageId : "", contentText: text, createdAt: at, metadata });
+        if (!previous && role === "user" && isDefaultConversationTitle(title)) title = deriveConversationTitleFromMessage(text) || title;
+      }
+      for (const call of applicationTools) {
+        const previous = group?.calls.get(call.id);
+        await persist(previous, { role: "assistant", kind: "tool_call", contentText: call.arguments, createdAt: call.at,
+          metadata: { ...previous?.metadata, toolCallId: call.id, tool: call.name,
+            conversationRuntime: { turnId, status: call.status } } });
+        if (call.result) {
+          const previousResult = group?.results.get(call.id);
+          await persist(previousResult, { role: "assistant", kind: "tool_result", contentText: JSON.stringify(call.result),
+            metadata: { ...previousResult?.metadata, toolCallId: call.id, tool: call.name, ok: call.result.ok === true,
+              conversationRuntime: { turnId } } });
+        }
+      }
+    }
+    const patch = { ...(added ? { messageCount: conversation.messageCount + added } : {}),
+      ...(title !== conversation.title ? { title } : {}),
+      ...(!isDeepStrictEqual(record.metadata, conversation.metadata) ? { metadata: record.metadata } : {}) };
+    if (Object.keys(patch).length) await conversationsRepository.updateById(id, patch, { trx });
+  }
+
+  async function access(id, operation, write) {
+    for (let attempt = 0; ; attempt += 1) {
+      let entered = false;
+      try {
+        return await conversationsRepository.transaction(async trx => {
+          const loaded = await load(id, trx, write);
+          requireUnambiguous(loaded.projection);
+          const storage = createConversationStorage({
+            readRecord: () => loaded.projection.record,
+            writeRecord: (_scope, record) => save(id, loaded, record, trx)
+          });
+          entered = true;
+          return storage[write ? "write" : "read"](id, operation);
+        });
+      } catch (error) {
+        // SQLite cannot wait asynchronously for another connection's writer.
+        // Retry acquiring the snapshot/lock only; never replay a caller or save.
+        if (entered || error.code !== "SQLITE_BUSY" || attempt >= 5) throw error;
+        await delay(10 * 2 ** attempt);
+      }
+    }
+  }
+
+  return Object.freeze({
+    read: (id, operation) => access(id, operation, false),
+    write: (id, operation) => access(id, operation, true),
+    preflight(id) {
+      return conversationsRepository.transaction(async trx => {
+        const { rows, projection } = await load(id, trx);
+        return { conversationId: id, rowCount: rows.length, issues: projection.issues };
+      });
+    }
+  });
+}
+
+export { createSqlConversationStorage, inspectSqlConversationRows };

package/src/server/support/assistantRouteContext.js

@@ -0,0 +1,91 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime";
+import { composeSchemaDefinitions } from "@jskit-ai/kernel/shared/validators";
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { resolveAssistantSurfaceConfig } from "../../shared/assistantSurfaces.js";
+import { assistantSurfaceRouteParamsValidator } from "../inputSchemas.js";
+
+function requireWorkspaceAssistantRouteParams(workspaceScopeSupport = null) {
+  if (!workspaceScopeSupport) {
+    throw new Error("Assistant workspace routes require workspace server scope support.");
+  }
+
+  return composeSchemaDefinitions(
+    [workspaceScopeSupport.params, assistantSurfaceRouteParamsValidator],
+    {
+      mode: "patch",
+      context: "assistant-runtime workspace surface route params"
+    }
+  );
+}
+
+function readWorkspaceInput(request, requiresWorkspace, workspaceScopeSupport = null) {
+  if (requiresWorkspace !== true) {
+    return {};
+  }
+
+  if (!workspaceScopeSupport) {
+    throw new Error("Assistant workspace routes require workspace server scope support.");
+  }
+
+  return workspaceScopeSupport.buildInputFromRouteParams(request?.input?.params);
+}
+
+function requireAssistantSurface(appConfig = {}, targetSurfaceId = "") {
+  const assistantSurface = resolveAssistantSurfaceConfig(appConfig, targetSurfaceId);
+  if (assistantSurface) {
+    return assistantSurface;
+  }
+
+  throw new AppError(404, "Assistant not found.");
+}
+
+function requireHostSurfaceId(request) {
+  const headerValue = Array.isArray(request?.headers?.["x-jskit-surface"])
+    ? request.headers["x-jskit-surface"][0]
+    : request?.headers?.["x-jskit-surface"];
+  const hostSurfaceId = normalizeSurfaceId(headerValue);
+  if (hostSurfaceId) {
+    return hostSurfaceId;
+  }
+
+  throw new AppError(400, "Assistant surface header x-jskit-surface is required.");
+}
+
+function resolveRouteRequestState(
+  request,
+  {
+    resolveCurrentAppConfig = () => ({}),
+    kind = "runtime",
+    requiresWorkspace = false,
+    workspaceScopeSupport = null
+  } = {}
+) {
+  const appConfig = resolveCurrentAppConfig();
+  const targetSurfaceId = normalizeSurfaceId(request?.input?.params?.surfaceId);
+  const assistantSurface = requireAssistantSurface(appConfig, targetSurfaceId);
+  const hostSurfaceId = requireHostSurfaceId(request);
+  const expectsWorkspace = kind === "settings"
+    ? assistantSurface.settingsSurfaceRequiresWorkspace
+    : assistantSurface.runtimeSurfaceRequiresWorkspace;
+  const expectedHostSurfaceId = kind === "settings"
+    ? assistantSurface.settingsSurfaceId
+    : assistantSurface.targetSurfaceId;
+
+  if (expectsWorkspace !== (requiresWorkspace === true)) {
+    throw new AppError(404, "Assistant route not found.");
+  }
+  if (hostSurfaceId !== expectedHostSurfaceId) {
+    throw new AppError(403, "Assistant route is not available on this surface.");
+  }
+
+  return Object.freeze({
+    assistantSurface,
+    hostSurfaceId,
+    actionInput: Object.freeze({
+      targetSurfaceId: assistantSurface.targetSurfaceId,
+      ...readWorkspaceInput(request, requiresWorkspace, workspaceScopeSupport)
+    })
+  });
+}
+
+export { requireWorkspaceAssistantRouteParams, resolveRouteRequestState };

package/src/server/support/createSurfaceAwareToolCatalog.js

@@ -42,9 +42,13 @@ function createSurfaceAwareToolCatalog(actions, { appConfig = {}, resolveAppConf
   }
 
   return Object.freeze({
-    resolveToolSet(context = {}) {
+    get limits() {
+      if (!schemaCatalog) schemaCatalog = createCatalog(actions, buildCatalogOptions(resolveCurrentAppConfig(), ""));
+      return schemaCatalog.limits;
+    },
+    resolveToolSet(context = {}, options) {
       const surfaceId = requireContextSurfaceId(context);
-      return resolveCatalog(surfaceId).resolveToolSet(context);
+      return resolveCatalog(surfaceId).resolveToolSet(context, options);
     },
     toOpenAiToolSchema(tool) {
       if (!schemaCatalog) {

package/src/shared/assistantSurfaces.js

@@ -3,6 +3,19 @@ import { normalizeObject, normalizeText } from "@jskit-ai/kernel/shared/support/
 
 const CONSOLE_OWNER_ACCESS_POLICY_ID = "console_owner";
 
+/** Declare one surface explicitly; full application surface maps remain supported. */
+function defineAssistantSurface(surfaceId, { pagesRoot = "", requiresWorkspace = false,
+  configScope = requiresWorkspace ? "workspace" : "global", ...definition } = {}) {
+  const id = normalizeSurfaceId(surfaceId);
+  if (!id) throw new TypeError("An assistant surface id is required.");
+  return Object.freeze({
+    surfaceDefinitions: Object.freeze({ [id]: Object.freeze({ ...definition, pagesRoot, requiresWorkspace }) }),
+    assistantSurfaces: Object.freeze({ [id]: Object.freeze({
+      settingsSurfaceId: id, configScope: normalizeAssistantConfigScope(configScope)
+    }) })
+  });
+}
+
 function resolveSurfaceDefinitions(appConfig = {}) {
   const source = normalizeObject(appConfig?.surfaceDefinitions);
   const resolved = {};
@@ -90,6 +103,7 @@ function resolveAssistantSurfaceConfig(appConfig = {}, targetSurfaceId = "") {
 }
 
 export {
+  defineAssistantSurface,
   normalizeAssistantConfigScope,
   resolveAssistantSurfaceConfig,
   resolveAssistantSurfacesConfig,

package/src/shared/conversationRealtime.js

@@ -0,0 +1,9 @@
+const ASSISTANT_CONVERSATION_SUBSCRIBE = "assistant.conversation.subscribe";
+const ASSISTANT_CONVERSATION_UNSUBSCRIBE = "assistant.conversation.unsubscribe";
+const ASSISTANT_CONVERSATION_EVENT = "assistant.conversation.event";
+
+export {
+  ASSISTANT_CONVERSATION_SUBSCRIBE,
+  ASSISTANT_CONVERSATION_UNSUBSCRIBE,
+  ASSISTANT_CONVERSATION_EVENT
+};

package/src/shared/index.js

@@ -1,5 +1,6 @@
 export { assistantRuntimeConfig } from "./assistantRuntimeConfig.js";
 export {
+  defineAssistantSurface,
   normalizeAssistantConfigScope,
   resolveAssistantSurfaceConfig,
   resolveAssistantSurfacesConfig,

package/test/actionDefinitions.test.js

@@ -97,3 +97,47 @@ test("assistant settings update keeps patch nested under one schema definition",
     patch: { systemPrompt: "Be concise." }
   });
 });
+
+test("host access wraps only canonical conversation definitions and receives the fixed subscription id", async () => {
+  const wrapped = [];
+  const subscribeActionId = "test.host.conversation.subscribe";
+  const conversation = { read: () => ({ id: "retained-conversation" }) };
+  const conversationAccess = {
+    subscribeActionId,
+    wrapAction(definition) {
+      wrapped.push(definition);
+      return { ...definition, permission: { require: "none" }, extensions: { hostAccess: true } };
+    }
+  };
+  const definitions = createAssistantActions({
+    config: CONFIG,
+    conversationRuntime: { open: async () => conversation },
+    conversationAccess,
+    assistantConfigService: {}
+  });
+  assert.deepEqual(wrapped.map(({ id }) => id), [
+    actionIds.conversationRead, actionIds.conversationSend, actionIds.conversationCancel, subscribeActionId,
+    actionIds.conversationInspectDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate
+  ]);
+  assert.equal(findDefinition(definitions, actionIds.conversationSubscribe), undefined);
+  assert.equal(findDefinition(definitions, subscribeActionId).audit.actionName, subscribeActionId);
+  for (const definition of wrapped) {
+    const adapted = findDefinition(definitions, definition.id);
+    assert.equal(adapted.input, definition.input);
+    assert.equal(adapted.execute, definition.execute);
+    assert.deepEqual(adapted.surfaces, ["home", "admin"]);
+  }
+  for (const id of [actionIds.settingsRead, actionIds.settingsUpdate]) {
+    const settings = findDefinition(definitions, id);
+    assert.equal(settings.permission.require, "authenticated");
+    assert.equal(settings.extensions.hostAccess, undefined);
+    assert.deepEqual(settings.surfaces, ["console", "admin"]);
+  }
+  assert.deepEqual(await findDefinition(definitions, actionIds.conversationRead).execute({
+    targetSurfaceId: "home", conversationId: "retained-conversation"
+  }, {}), { id: "retained-conversation" });
+  const legacy = createAssistantActions({ config: CONFIG, chatService: {}, assistantConfigService: {},
+    conversationAccess: { wrapAction() { assert.fail("Legacy definitions must retain their own access policy."); } } });
+  assert.deepEqual(legacy.map(({ id }) => id), createDefinitions().map(({ id }) => id));
+  assert.ok(legacy.every(definition => definition.permission.require === "authenticated"));
+});

package/test/aiConnections.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createAiConnectionResolver } from "../../connectors-catalog/src/server/ai.js";
-import { createAssistantAiClientFactory } from "../src/server/AssistantProvider.js";
+import { createAssistantAiClientFactory } from "../src/server/createAssistantRuntime.js";
 
 test("assistant connections authorize each request and resolve rotated and individual credentials afresh", async t => {
   const keys = { alice: "alice-first", bob: "bob-only" };