@jskit-ai/assistant-runtime 0.1.1

package/src/server/services/transcriptService.js

@@ -0,0 +1,331 @@
+import { AppError, parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { normalizeObject, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeConversationStatus } from "@jskit-ai/assistant-core/shared";
+
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 200;
+const DEFAULT_MESSAGES_PAGE_SIZE = 200;
+const MAX_MESSAGES_PAGE_SIZE = 500;
+const DEFAULT_CONVERSATION_TITLE = "New conversation";
+const MAX_CONVERSATION_TITLE_LENGTH = 80;
+
+function resolveWorkspaceId(workspace, { required = false } = {}) {
+  const workspaceId = parsePositiveInteger(workspace?.id || workspace);
+  if (!workspaceId && required) {
+    throw new AppError(409, "Workspace selection required.");
+  }
+
+  return workspaceId || null;
+}
+
+function resolveActorUserId(user, { required = false } = {}) {
+  const actorUserId = parsePositiveInteger(user?.id);
+  if (!actorUserId && required) {
+    throw new AppError(401, "Authentication required.");
+  }
+
+  return actorUserId || null;
+}
+
+function normalizePagination(pagination = {}, { defaultPageSize = DEFAULT_PAGE_SIZE, maxPageSize = MAX_PAGE_SIZE } = {}) {
+  const page = Math.max(1, parsePositiveInteger(pagination.page) || 1);
+  const pageSize = Math.max(1, Math.min(maxPageSize, parsePositiveInteger(pagination.pageSize) || defaultPageSize));
+
+  return {
+    page,
+    pageSize
+  };
+}
+
+function normalizeCursorPagination(query = {}, { defaultLimit = DEFAULT_PAGE_SIZE, maxLimit = MAX_PAGE_SIZE } = {}) {
+  const cursor = parsePositiveInteger(query.cursor) || 0;
+  const limit = Math.max(1, Math.min(maxLimit, parsePositiveInteger(query.limit) || defaultLimit));
+
+  return {
+    cursor,
+    limit
+  };
+}
+
+function deriveConversationTitleFromMessage(contentText) {
+  const normalized = String(contentText == null ? "" : contentText).replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return "";
+  }
+
+  return normalized.slice(0, MAX_CONVERSATION_TITLE_LENGTH).trim();
+}
+
+function isDefaultConversationTitle(value) {
+  return normalizeText(value).toLowerCase() === DEFAULT_CONVERSATION_TITLE.toLowerCase();
+}
+
+function requireAssistantSurface(assistantSurface = {}) {
+  const targetSurfaceId = normalizeSurfaceId(assistantSurface?.targetSurfaceId);
+  if (!targetSurfaceId) {
+    throw new TypeError("assistant transcript service requires assistantSurface.targetSurfaceId.");
+  }
+
+  return Object.freeze({
+    targetSurfaceId,
+    runtimeSurfaceRequiresWorkspace: assistantSurface?.runtimeSurfaceRequiresWorkspace === true
+  });
+}
+
+function createTranscriptService({ conversationsRepository, messagesRepository } = {}) {
+  if (!conversationsRepository || !messagesRepository) {
+    throw new Error("createTranscriptService requires conversationsRepository and messagesRepository.");
+  }
+
+  function resolveExpectedWorkspaceId(assistantSurface, workspace) {
+    const resolvedAssistantSurface = requireAssistantSurface(assistantSurface);
+    return resolveWorkspaceId(workspace, {
+      required: resolvedAssistantSurface.runtimeSurfaceRequiresWorkspace === true
+    });
+  }
+
+  async function createConversationForTurn(assistantSurface, workspace, user, options = {}) {
+    const resolvedAssistantSurface = requireAssistantSurface(assistantSurface);
+    const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, workspace);
+    const actorUserId = resolveActorUserId(user, {
+      required: true
+    });
+    const source = normalizeObject(options);
+    const conversationId = parsePositiveInteger(source.conversationId);
+
+    if (conversationId) {
+      const existing = await conversationsRepository.findByIdForActorScope(conversationId, {
+        workspaceId,
+        actorUserId,
+        surfaceId: resolvedAssistantSurface.targetSurfaceId
+      });
+      if (!existing) {
+        throw new AppError(404, "Conversation not found.");
+      }
+
+      if (existing.status !== "active") {
+        const reopened = await conversationsRepository.updateById(existing.id, {
+          status: "active",
+          endedAt: null
+        });
+
+        return {
+          conversation: reopened,
+          created: false
+        };
+      }
+
+      return {
+        conversation: existing,
+        created: false
+      };
+    }
+
+    const createdConversation = await conversationsRepository.create({
+      workspaceId,
+      createdByUserId: actorUserId,
+      title: normalizeText(source.title) || DEFAULT_CONVERSATION_TITLE,
+      status: "active",
+      provider: normalizeText(source.provider),
+      model: normalizeText(source.model),
+      surfaceId: normalizeSurfaceId(source.surfaceId) || resolvedAssistantSurface.targetSurfaceId,
+      metadata: {
+        firstMessageId: normalizeText(source.messageId)
+      }
+    });
+
+    return {
+      conversation: createdConversation,
+      created: true
+    };
+  }
+
+  async function appendMessage(assistantSurface, conversationId, payload = {}, options = {}) {
+    const resolvedAssistantSurface = requireAssistantSurface(assistantSurface);
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      throw new TypeError("appendMessage requires conversationId.");
+    }
+
+    const source = normalizeObject(payload);
+    const context = normalizeObject(options.context);
+    const actorUserId = parsePositiveInteger(source.actorUserId) || resolveActorUserId(context.actor);
+    const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, options.workspace || context.workspace);
+    const conversation = await conversationsRepository.findByIdForActorScope(numericConversationId, {
+      workspaceId,
+      actorUserId,
+      surfaceId: resolvedAssistantSurface.targetSurfaceId
+    });
+    if (!conversation) {
+      throw new AppError(404, "Conversation not found.");
+    }
+
+    const createdMessage = await messagesRepository.create({
+      conversationId: numericConversationId,
+      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(numericConversationId, 1);
+
+    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(numericConversationId, {
+          title: derivedTitle
+        });
+      }
+    }
+
+    return {
+      conversationId: numericConversationId,
+      message: createdMessage
+    };
+  }
+
+  async function completeConversation(assistantSurface, conversationId, payload = {}, options = {}) {
+    const resolvedAssistantSurface = requireAssistantSurface(assistantSurface);
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      throw new TypeError("completeConversation requires conversationId.");
+    }
+
+    const source = normalizeObject(payload);
+    const context = normalizeObject(options.context);
+    const actorUserId = resolveActorUserId(context.actor, {
+      required: true
+    });
+    const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, options.workspace || context.workspace);
+    const existing = await conversationsRepository.findByIdForActorScope(numericConversationId, {
+      workspaceId,
+      actorUserId,
+      surfaceId: resolvedAssistantSurface.targetSurfaceId
+    });
+    if (!existing) {
+      throw new AppError(404, "Conversation not found.");
+    }
+
+    return conversationsRepository.updateById(numericConversationId, {
+      status: normalizeConversationStatus(source.status, {
+        fallback: "completed"
+      }),
+      endedAt: source.endedAt || new Date(),
+      metadata: {
+        ...normalizeObject(existing.metadata),
+        ...normalizeObject(source.metadata)
+      }
+    });
+  }
+
+  async function listConversationsForUser(assistantSurface, workspace, user, query = {}) {
+    const resolvedAssistantSurface = requireAssistantSurface(assistantSurface);
+    const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, workspace);
+    const actorUserId = resolveActorUserId(user, {
+      required: true
+    });
+    const pagination = normalizeCursorPagination(query, {
+      defaultLimit: DEFAULT_PAGE_SIZE,
+      maxLimit: MAX_PAGE_SIZE
+    });
+
+    const status = normalizeConversationStatus(query.status, {
+      fallback: ""
+    });
+    const filters = {
+      ...(status ? { status } : {})
+    };
+
+    return conversationsRepository.listForActorScope(
+      {
+        workspaceId,
+        actorUserId,
+        surfaceId: resolvedAssistantSurface.targetSurfaceId,
+        pagination: {
+          cursor: pagination.cursor,
+          limit: pagination.limit
+        },
+        filters
+      }
+    );
+  }
+
+  async function getConversationMessagesForUser(assistantSurface, workspace, user, conversationId, query = {}) {
+    const resolvedAssistantSurface = requireAssistantSurface(assistantSurface);
+    const workspaceId = resolveExpectedWorkspaceId(resolvedAssistantSurface, workspace);
+    const actorUserId = resolveActorUserId(user, {
+      required: true
+    });
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      throw new AppError(400, "Validation failed.", {
+        details: {
+          fieldErrors: {
+            conversationId: "conversationId must be a positive integer."
+          }
+        }
+      });
+    }
+
+    const conversation = await conversationsRepository.findByIdForActorScope(
+      numericConversationId,
+      {
+        workspaceId,
+        actorUserId,
+        surfaceId: resolvedAssistantSurface.targetSurfaceId
+      }
+    );
+    if (!conversation) {
+      throw new AppError(404, "Conversation not found.");
+    }
+
+    const pagination = normalizePagination(query, {
+      defaultPageSize: DEFAULT_MESSAGES_PAGE_SIZE,
+      maxPageSize: MAX_MESSAGES_PAGE_SIZE
+    });
+    const total = await messagesRepository.countByConversationScope(
+      numericConversationId,
+      {
+        workspaceId
+      }
+    );
+    const totalPages = Math.max(1, Math.ceil(total / pagination.pageSize));
+    const page = Math.min(pagination.page, totalPages);
+    const entries = await messagesRepository.listByConversationScope(
+      numericConversationId,
+      {
+        workspaceId
+      },
+      {
+        page,
+        pageSize: pagination.pageSize
+      }
+    );
+
+    return {
+      conversation,
+      entries,
+      page,
+      pageSize: pagination.pageSize,
+      total,
+      totalPages
+    };
+  }
+
+  return Object.freeze({
+    createConversationForTurn,
+    appendMessage,
+    completeConversation,
+    listConversationsForUser,
+    getConversationMessagesForUser
+  });
+}
+
+export { createTranscriptService };

package/src/server/support/assistantServerConfig.js

@@ -0,0 +1,106 @@
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { normalizeObject, normalizeText, normalizeUniqueTextList } from "@jskit-ai/kernel/shared/support/normalize";
+import {
+  DEFAULT_AI_TIMEOUT_MS,
+  normalizeOptionalHttpUrl,
+  normalizeTimeoutMs
+} from "@jskit-ai/assistant-core/server";
+
+function resolveAssistantServerConfigMap(appConfig = {}) {
+  const source = normalizeObject(appConfig?.assistantServer);
+  const resolved = {};
+
+  for (const [rawSurfaceId, rawEntry] of Object.entries(source)) {
+    const targetSurfaceId = normalizeSurfaceId(rawSurfaceId);
+    const entry = normalizeObject(rawEntry);
+    if (!targetSurfaceId) {
+      continue;
+    }
+
+    resolved[targetSurfaceId] = Object.freeze({
+      aiConfigPrefix: normalizeText(entry.aiConfigPrefix),
+      provider: normalizeText(entry.provider).toLowerCase(),
+      apiKey: normalizeText(entry.apiKey),
+      baseUrl: normalizeText(entry.baseUrl),
+      model: normalizeText(entry.model),
+      timeoutMs: entry.timeoutMs,
+      barredActionIds: Object.freeze(normalizeUniqueTextList(entry.barredActionIds, { acceptSingle: true })),
+      toolSkipActionPrefixes: Object.freeze(normalizeUniqueTextList(entry.toolSkipActionPrefixes, { acceptSingle: true }))
+    });
+  }
+
+  return Object.freeze(resolved);
+}
+
+function resolveAssistantServerConfig(appConfig = {}, targetSurfaceId = "") {
+  const normalizedTargetSurfaceId = normalizeSurfaceId(targetSurfaceId);
+  if (!normalizedTargetSurfaceId) {
+    return Object.freeze({});
+  }
+
+  const serverConfigMap = resolveAssistantServerConfigMap(appConfig);
+  return serverConfigMap[normalizedTargetSurfaceId] || Object.freeze({});
+}
+
+function readPrefixedEnvValue(env = {}, prefix = "", key = "") {
+  const normalizedPrefix = normalizeText(prefix);
+  const normalizedKey = normalizeText(key);
+  if (!normalizedPrefix || !normalizedKey) {
+    return "";
+  }
+
+  return normalizeText(env[`${normalizedPrefix}_${normalizedKey}`]);
+}
+
+function resolveAssistantAiConfig({ appConfig = {}, env = {} } = {}, targetSurfaceId = "") {
+  const surfaceServerConfig = resolveAssistantServerConfig(appConfig, targetSurfaceId);
+  const normalizedTargetSurfaceId = normalizeSurfaceId(targetSurfaceId);
+  if (!normalizedTargetSurfaceId) {
+    throw new Error("assistant AI config requires targetSurfaceId.");
+  }
+
+  const aiConfigPrefix = normalizeText(surfaceServerConfig.aiConfigPrefix);
+  if (!aiConfigPrefix) {
+    throw new Error(
+      `assistant server config for surface "${normalizedTargetSurfaceId}" requires assistantServer.${normalizedTargetSurfaceId}.aiConfigPrefix.`
+    );
+  }
+
+  const provider = normalizeText(
+    readPrefixedEnvValue(env, aiConfigPrefix, "AI_PROVIDER") || surfaceServerConfig.provider
+  ).toLowerCase() || "openai";
+  const apiKey = normalizeText(
+    readPrefixedEnvValue(env, aiConfigPrefix, "AI_API_KEY") || surfaceServerConfig.apiKey
+  );
+  const baseUrl = normalizeOptionalHttpUrl(
+    readPrefixedEnvValue(env, aiConfigPrefix, "AI_BASE_URL") || surfaceServerConfig.baseUrl,
+    {
+      context: "assistant AI_BASE_URL"
+    }
+  );
+  const model = normalizeText(
+    readPrefixedEnvValue(env, aiConfigPrefix, "AI_MODEL") || surfaceServerConfig.model
+  );
+  const timeoutMs = normalizeTimeoutMs(
+    readPrefixedEnvValue(env, aiConfigPrefix, "AI_TIMEOUT_MS") || surfaceServerConfig.timeoutMs,
+    DEFAULT_AI_TIMEOUT_MS
+  );
+
+  return Object.freeze({
+    aiConfigPrefix,
+    ai: Object.freeze({
+      enabled: Boolean(apiKey),
+      provider,
+      apiKey,
+      baseUrl,
+      model,
+      timeoutMs
+    })
+  });
+}
+
+export {
+  resolveAssistantServerConfigMap,
+  resolveAssistantServerConfig,
+  resolveAssistantAiConfig
+};

package/src/server/support/createSurfaceAwareToolCatalog.js

@@ -0,0 +1,64 @@
+import { createServiceToolCatalog } from "@jskit-ai/assistant-core/server";
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveAssistantServerConfig } from "./assistantServerConfig.js";
+
+function buildCatalogOptions(appConfig = {}, surfaceId = "") {
+  const surfaceConfig = resolveAssistantServerConfig(appConfig, surfaceId);
+
+  return Object.freeze({
+    barredActionIds: surfaceConfig.barredActionIds || [],
+    skipActionPrefixes: Object.freeze(["assistant.", ...(surfaceConfig.toolSkipActionPrefixes || [])])
+  });
+}
+
+function requireContextSurfaceId(context = {}) {
+  const surfaceId = normalizeSurfaceId(context?.surface);
+  if (surfaceId) {
+    return surfaceId;
+  }
+
+  throw new Error("assistant surface-aware tool catalog requires context.surface.");
+}
+
+function createSurfaceAwareToolCatalog(scope, { appConfig = {}, resolveAppConfig = null, createCatalog = createServiceToolCatalog } = {}) {
+  if (!scope) {
+    throw new Error("createSurfaceAwareToolCatalog requires scope.");
+  }
+
+  const resolveCurrentAppConfig =
+    typeof resolveAppConfig === "function" ? () => normalizeObject(resolveAppConfig()) : () => normalizeObject(appConfig);
+  const cache = new Map();
+  let schemaCatalog = null;
+
+  function resolveCatalog(surfaceId = "") {
+    if (cache.has(surfaceId)) {
+      return cache.get(surfaceId);
+    }
+
+    const nextCatalog = createCatalog(scope, buildCatalogOptions(resolveCurrentAppConfig(), surfaceId));
+    cache.set(surfaceId, nextCatalog);
+    return nextCatalog;
+  }
+
+  return Object.freeze({
+    resolveToolSet(context = {}) {
+      const surfaceId = requireContextSurfaceId(context);
+      return resolveCatalog(surfaceId).resolveToolSet(context);
+    },
+    toOpenAiToolSchema(tool) {
+      if (!schemaCatalog) {
+        schemaCatalog = createCatalog(scope, buildCatalogOptions(resolveCurrentAppConfig(), ""));
+      }
+
+      return schemaCatalog.toOpenAiToolSchema(tool);
+    },
+    executeToolCall(payload = {}) {
+      const context = payload?.context && typeof payload.context === "object" ? payload.context : {};
+      const surfaceId = requireContextSurfaceId(context);
+      return resolveCatalog(surfaceId).executeToolCall(payload);
+    }
+  });
+}
+
+export { createSurfaceAwareToolCatalog };

package/src/shared/assistantRuntimeConfig.js

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

package/src/shared/assistantSurfaces.js

@@ -0,0 +1,97 @@
+import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
+import { normalizeObject, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+
+const CONSOLE_OWNER_ACCESS_POLICY_ID = "console_owner";
+
+function resolveSurfaceDefinitions(appConfig = {}) {
+  const source = normalizeObject(appConfig?.surfaceDefinitions);
+  const resolved = {};
+
+  for (const [rawSurfaceId, rawDefinition] of Object.entries(source)) {
+    const surfaceId = normalizeSurfaceId(rawSurfaceId);
+    const definition = normalizeObject(rawDefinition);
+    if (!surfaceId || definition.enabled === false) {
+      continue;
+    }
+
+    resolved[surfaceId] = Object.freeze({
+      id: surfaceId,
+      requiresWorkspace: definition.requiresWorkspace === true,
+      accessPolicyId: normalizeText(definition.accessPolicyId).toLowerCase()
+    });
+  }
+
+  return Object.freeze(resolved);
+}
+
+function resolveAssistantSurfacesConfig(appConfig = {}) {
+  const source = normalizeObject(appConfig?.assistantSurfaces);
+  const resolved = {};
+
+  for (const [rawSurfaceId, rawEntry] of Object.entries(source)) {
+    const targetSurfaceId = normalizeSurfaceId(rawSurfaceId);
+    const entry = normalizeObject(rawEntry);
+    if (!targetSurfaceId) {
+      continue;
+    }
+
+    resolved[targetSurfaceId] = Object.freeze({
+      settingsSurfaceId: normalizeSurfaceId(entry.settingsSurfaceId),
+      configScope: normalizeAssistantConfigScope(entry.configScope)
+    });
+  }
+
+  return Object.freeze(resolved);
+}
+
+function normalizeAssistantConfigScope(value = "") {
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized === "workspace") {
+    return "workspace";
+  }
+
+  return "global";
+}
+
+function resolveAssistantSurfaceConfig(appConfig = {}, targetSurfaceId = "") {
+  const normalizedTargetSurfaceId = normalizeSurfaceId(targetSurfaceId);
+  if (!normalizedTargetSurfaceId) {
+    return null;
+  }
+
+  const assistantSurfaces = resolveAssistantSurfacesConfig(appConfig);
+  const surfaceConfig = assistantSurfaces[normalizedTargetSurfaceId];
+  if (!surfaceConfig) {
+    return null;
+  }
+
+  const surfaceDefinitions = resolveSurfaceDefinitions(appConfig);
+  const runtimeSurface = surfaceDefinitions[normalizedTargetSurfaceId];
+  const settingsSurface = surfaceDefinitions[surfaceConfig.settingsSurfaceId];
+  if (!runtimeSurface || !settingsSurface) {
+    return null;
+  }
+
+  if (
+    surfaceConfig.configScope === "workspace" &&
+    (runtimeSurface.requiresWorkspace !== true || settingsSurface.requiresWorkspace !== true)
+  ) {
+    return null;
+  }
+
+  return Object.freeze({
+    targetSurfaceId: normalizedTargetSurfaceId,
+    settingsSurfaceId: settingsSurface.id,
+    configScope: surfaceConfig.configScope,
+    runtimeSurfaceRequiresWorkspace: runtimeSurface.requiresWorkspace === true,
+    settingsSurfaceRequiresWorkspace: settingsSurface.requiresWorkspace === true,
+    settingsSurfaceRequiresConsoleOwner: settingsSurface.accessPolicyId === CONSOLE_OWNER_ACCESS_POLICY_ID
+  });
+}
+
+export {
+  normalizeAssistantConfigScope,
+  resolveAssistantSurfaceConfig,
+  resolveAssistantSurfacesConfig,
+  resolveSurfaceDefinitions
+};

package/src/shared/index.js

@@ -0,0 +1,7 @@
+export { assistantRuntimeConfig } from "./assistantRuntimeConfig.js";
+export {
+  normalizeAssistantConfigScope,
+  resolveAssistantSurfaceConfig,
+  resolveAssistantSurfacesConfig,
+  resolveSurfaceDefinitions
+} from "./assistantSurfaces.js";

package/templates/migrations/assistant_config_initial.cjs

@@ -0,0 +1,27 @@
+exports.up = async function up(knex) {
+  const hasTable = await knex.schema.hasTable("assistant_config");
+  if (!hasTable) {
+    const hasWorkspacesTable = await knex.schema.hasTable("workspaces");
+
+    await knex.schema.createTable("assistant_config", (table) => {
+      table.increments("id").unsigned().primary();
+      table.string("target_surface_id", 64).notNullable();
+      table.string("scope_key", 160).notNullable();
+      table.integer("workspace_id").unsigned().nullable();
+      if (hasWorkspacesTable) {
+        table.foreign("workspace_id").references("id").inTable("workspaces").onDelete("CASCADE");
+      }
+      table.text("system_prompt").notNullable().defaultTo("");
+      table.timestamp("created_at").notNullable().defaultTo(knex.fn.now());
+      table.timestamp("updated_at").notNullable().defaultTo(knex.fn.now());
+
+      table.unique(["target_surface_id", "scope_key"], "uq_assistant_config_target_surface_scope");
+      table.index(["target_surface_id"], "idx_assistant_config_target_surface");
+      table.index(["workspace_id"], "idx_assistant_config_workspace");
+    });
+  }
+};
+
+exports.down = async function down(knex) {
+  await knex.schema.dropTableIfExists("assistant_config");
+};