@jskit-ai/assistant 0.1.32 → 0.1.34

package/templates/src/local-package/server/repositories/assistantConfigRepository.js

@@ -0,0 +1,141 @@
+import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveInsertedId } from "@jskit-ai/assistant-core/server";
+import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
+
+function normalizeTargetSurfaceId(value = "") {
+  return normalizeText(value).toLowerCase() || assistantRuntimeConfig.runtimeSurfaceId;
+}
+
+function normalizeWorkspaceId(value) {
+  return parsePositiveInteger(value) || null;
+}
+
+function buildScopeKey(targetSurfaceId, workspaceId = null) {
+  const normalizedTargetSurfaceId = normalizeTargetSurfaceId(targetSurfaceId);
+  const normalizedWorkspaceId = normalizeWorkspaceId(workspaceId);
+  if (normalizedWorkspaceId) {
+    return `${normalizedTargetSurfaceId}:workspace:${normalizedWorkspaceId}`;
+  }
+
+  return `${normalizedTargetSurfaceId}:global`;
+}
+
+function mapConfigRow(row = {}) {
+  return {
+    targetSurfaceId: normalizeTargetSurfaceId(row.target_surface_id),
+    scopeKey: normalizeText(row.scope_key),
+    workspaceId: normalizeWorkspaceId(row.workspace_id),
+    settings: {
+      systemPrompt: String(row.system_prompt || "")
+    }
+  };
+}
+
+function createDefaultRecord({ targetSurfaceId = "", workspaceId = null } = {}) {
+  const normalizedTargetSurfaceId = normalizeTargetSurfaceId(targetSurfaceId);
+  const normalizedWorkspaceId = normalizeWorkspaceId(workspaceId);
+
+  return {
+    targetSurfaceId: normalizedTargetSurfaceId,
+    scopeKey: buildScopeKey(normalizedTargetSurfaceId, normalizedWorkspaceId),
+    workspaceId: normalizedWorkspaceId,
+    settings: {
+      systemPrompt: ""
+    }
+  };
+}
+
+function createRepository(knex) {
+  if (!knex || typeof knex !== "function") {
+    throw new Error("createAssistantConfigRepository requires knex client.");
+  }
+
+  async function findByScope({ targetSurfaceId = "", workspaceId = null } = {}, options = {}) {
+    const client = options?.trx || knex;
+    const defaultRecord = createDefaultRecord({
+      targetSurfaceId,
+      workspaceId
+    });
+    const row = await client(assistantRuntimeConfig.configTable)
+      .where({
+        target_surface_id: defaultRecord.targetSurfaceId,
+        scope_key: defaultRecord.scopeKey
+      })
+      .first();
+
+    return row ? mapConfigRow(row) : null;
+  }
+
+  async function upsertByScope({ targetSurfaceId = "", workspaceId = null, patch = {} } = {}, options = {}) {
+    const client = options?.trx || knex;
+    const defaultRecord = createDefaultRecord({
+      targetSurfaceId,
+      workspaceId
+    });
+    const existing = await findByScope(defaultRecord, {
+      trx: client
+    });
+    const nextSystemPrompt = Object.hasOwn(patch || {}, "systemPrompt")
+      ? String(patch.systemPrompt || "")
+      : String(existing?.settings?.systemPrompt || defaultRecord.settings.systemPrompt);
+    const now = new Date();
+
+    if (existing) {
+      await client(assistantRuntimeConfig.configTable)
+        .where({
+          target_surface_id: defaultRecord.targetSurfaceId,
+          scope_key: defaultRecord.scopeKey
+        })
+        .update({
+          workspace_id: defaultRecord.workspaceId,
+          system_prompt: nextSystemPrompt,
+          updated_at: now
+        });
+
+      return {
+        ...defaultRecord,
+        settings: {
+          systemPrompt: nextSystemPrompt
+        }
+      };
+    }
+
+    const insertResult = await client(assistantRuntimeConfig.configTable).insert({
+      target_surface_id: defaultRecord.targetSurfaceId,
+      scope_key: defaultRecord.scopeKey,
+      workspace_id: defaultRecord.workspaceId,
+      system_prompt: nextSystemPrompt,
+      created_at: now,
+      updated_at: now
+    });
+    const insertedId = resolveInsertedId(insertResult);
+    if (!insertedId) {
+      return {
+        ...defaultRecord,
+        settings: {
+          systemPrompt: nextSystemPrompt
+        }
+      };
+    }
+
+    const insertedRow = await client(assistantRuntimeConfig.configTable)
+      .where({ id: insertedId })
+      .first();
+
+    return insertedRow ? mapConfigRow(insertedRow) : {
+      ...defaultRecord,
+      settings: {
+        systemPrompt: nextSystemPrompt
+      }
+    };
+  }
+
+  return Object.freeze({
+    createDefaultRecord,
+    findByScope,
+    upsertByScope
+  });
+}
+
+export { createRepository };

package/{src → templates/src/local-package}/server/repositories/conversationsRepository.js

@@ -1,27 +1,37 @@
+import { runInTransaction } from "@jskit-ai/database-runtime/shared/repositoryOptions";
 import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { runInTransaction } from "@jskit-ai/database-runtime/shared/repositoryOptions";
 import {
   parseJsonObject,
+  resolveInsertedId,
   stringifyJsonObject,
-  toIso,
-  resolveInsertedId
-} from "./repositoryPersistenceUtils.js";
+  toIso
+} from "@jskit-ai/assistant-core/server";
+import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
+
+function normalizeWorkspaceId(value) {
+  return parsePositiveInteger(value) || null;
+}
+
+function applyWorkspaceScope(query, columnName, workspaceId) {
+  const normalizedWorkspaceId = normalizeWorkspaceId(workspaceId);
+  if (normalizedWorkspaceId) {
+    return query.where(columnName, normalizedWorkspaceId);
+  }
+
+  return query.whereNull(columnName);
+}
 
 function mapConversationRow(row = {}) {
   return {
     id: Number(row.id),
-    workspaceId: Number(row.workspace_id),
-    workspaceSlug: String(row.workspace_slug || ""),
-    workspaceName: String(row.workspace_name || ""),
+    workspaceId: normalizeWorkspaceId(row.workspace_id),
     title: String(row.title || "New conversation"),
     createdByUserId: row.created_by_user_id == null ? null : Number(row.created_by_user_id),
-    createdByUserDisplayName: String(row.created_by_user_display_name || ""),
-    createdByUserEmail: String(row.created_by_user_email || ""),
     status: String(row.status || "active"),
     provider: String(row.provider || ""),
     model: String(row.model || ""),
-    surfaceSid: String(row.surface_sid || ""),
+    surfaceId: String(row.surface_id || ""),
     startedAt: toIso(row.started_at),
     endedAt: row.ended_at ? toIso(row.ended_at) : null,
     messageCount: Number(row.message_count || 0),
@@ -42,19 +52,10 @@ function normalizeCursorPagination(pagination = {}, { defaultLimit = 20, maxLimi
 }
 
 function createConversationBaseQuery(client) {
-  return client("ai_conversations as c")
-    .leftJoin("workspaces as w", "w.id", "c.workspace_id")
-    .leftJoin("users as u", "u.id", "c.created_by_user_id")
-    .select(
-      "c.*",
-      client.raw("COALESCE(w.slug, '') AS workspace_slug"),
-      client.raw("COALESCE(w.name, '') AS workspace_name"),
-      client.raw("COALESCE(u.display_name, '') AS created_by_user_display_name"),
-      client.raw("COALESCE(u.email, '') AS created_by_user_email")
-    );
+  return client(`${assistantRuntimeConfig.conversationsTable} as c`).select("c.*");
 }
 
-function createConversationsRepository(knex) {
+function createRepository(knex) {
   if (!knex || typeof knex !== "function") {
     throw new Error("createConversationsRepository requires knex client.");
   }
@@ -73,20 +74,19 @@ function createConversationsRepository(knex) {
     return row ? mapConversationRow(row) : null;
   }
 
-  async function findByIdForWorkspaceAndUser(conversationId, workspaceId, actorUserId, options = {}) {
+  async function findByIdForActorScope(conversationId, { workspaceId = null, actorUserId = null } = {}, options = {}) {
     const numericConversationId = parsePositiveInteger(conversationId);
-    const numericWorkspaceId = parsePositiveInteger(workspaceId);
     const numericActorUserId = parsePositiveInteger(actorUserId);
-    if (!numericConversationId || !numericWorkspaceId || !numericActorUserId) {
+    if (!numericConversationId || !numericActorUserId) {
       return null;
     }
 
     const client = options?.trx || knex;
-    const row = await createConversationBaseQuery(client)
+    const query = createConversationBaseQuery(client)
       .where("c.id", numericConversationId)
-      .where("c.workspace_id", numericWorkspaceId)
-      .where("c.created_by_user_id", numericActorUserId)
-      .first();
+      .where("c.created_by_user_id", numericActorUserId);
+    applyWorkspaceScope(query, "c.workspace_id", workspaceId);
+    const row = await query.first();
 
     return row ? mapConversationRow(row) : null;
   }
@@ -94,14 +94,14 @@ function createConversationsRepository(knex) {
   async function create(payload = {}, options = {}) {
     const client = options?.trx || knex;
     const now = new Date();
-    const insertResult = await client("ai_conversations").insert({
-      workspace_id: parsePositiveInteger(payload.workspaceId),
+    const insertResult = await client(assistantRuntimeConfig.conversationsTable).insert({
+      workspace_id: normalizeWorkspaceId(payload.workspaceId),
       created_by_user_id: parsePositiveInteger(payload.createdByUserId) || null,
       title: normalizeText(payload.title) || "New conversation",
       status: normalizeText(payload.status).toLowerCase() || "active",
       provider: normalizeText(payload.provider),
       model: normalizeText(payload.model),
-      surface_sid: normalizeText(payload.surfaceSid).toLowerCase() || "admin",
+      surface_id: normalizeText(payload.surfaceId).toLowerCase() || assistantRuntimeConfig.runtimeSurfaceId,
       message_count: parsePositiveInteger(payload.messageCount) || 0,
       metadata_json: stringifyJsonObject(payload.metadata),
       started_at: payload.startedAt ? new Date(payload.startedAt) : now,
@@ -140,8 +140,8 @@ function createConversationsRepository(knex) {
     if (Object.hasOwn(patch, "model")) {
       updatePatch.model = normalizeText(patch.model);
     }
-    if (Object.hasOwn(patch, "surfaceSid")) {
-      updatePatch.surface_sid = normalizeText(patch.surfaceSid).toLowerCase() || "admin";
+    if (Object.hasOwn(patch, "surfaceId")) {
+      updatePatch.surface_id = normalizeText(patch.surfaceId).toLowerCase() || assistantRuntimeConfig.runtimeSurfaceId;
     }
     if (Object.hasOwn(patch, "messageCount")) {
       updatePatch.message_count = Math.max(0, Number(patch.messageCount || 0));
@@ -155,7 +155,9 @@ function createConversationsRepository(knex) {
 
     if (Object.keys(updatePatch).length > 0) {
       updatePatch.updated_at = new Date();
-      await client("ai_conversations").where({ id: numericConversationId }).update(updatePatch);
+      await client(assistantRuntimeConfig.conversationsTable)
+        .where({ id: numericConversationId })
+        .update(updatePatch);
     }
 
     return findById(numericConversationId, {
@@ -171,7 +173,7 @@ function createConversationsRepository(knex) {
 
     const client = options?.trx || knex;
     const incrementBy = Number.isInteger(Number(delta)) ? Number(delta) : 1;
-    await client("ai_conversations")
+    await client(assistantRuntimeConfig.conversationsTable)
       .where({ id: numericConversationId })
       .update({
         message_count: client.raw("GREATEST(0, message_count + ?)", [incrementBy]),
@@ -183,10 +185,9 @@ function createConversationsRepository(knex) {
     });
   }
 
-  async function listForWorkspaceAndUser(workspaceId, actorUserId, pagination = {}, filters = {}, options = {}) {
-    const numericWorkspaceId = parsePositiveInteger(workspaceId);
+  async function listForActorScope({ workspaceId = null, actorUserId = null, pagination = {}, filters = {} } = {}, options = {}) {
     const numericActorUserId = parsePositiveInteger(actorUserId);
-    if (!numericWorkspaceId || !numericActorUserId) {
+    if (!numericActorUserId) {
       return {
         items: [],
         nextCursor: null
@@ -195,10 +196,8 @@ function createConversationsRepository(knex) {
 
     const client = options?.trx || knex;
     const { cursor, limit } = normalizeCursorPagination(pagination);
-
-    let query = createConversationBaseQuery(client)
-      .where("c.workspace_id", numericWorkspaceId)
-      .where("c.created_by_user_id", numericActorUserId);
+    let query = createConversationBaseQuery(client).where("c.created_by_user_id", numericActorUserId);
+    query = applyWorkspaceScope(query, "c.workspace_id", workspaceId);
 
     const normalizedStatus = normalizeText(filters.status).toLowerCase();
     if (normalizedStatus) {
@@ -229,13 +228,13 @@ function createConversationsRepository(knex) {
 
   return Object.freeze({
     findById,
-    findByIdForWorkspaceAndUser,
+    findByIdForActorScope,
     create,
     updateById,
     incrementMessageCount,
-    listForWorkspaceAndUser,
+    listForActorScope,
     transaction
   });
 }
 
-export { createConversationsRepository as createRepository, createConversationsRepository };
+export { createRepository };

package/{src → templates/src/local-package}/server/repositories/messagesRepository.js

@@ -1,18 +1,32 @@
+import { runInTransaction } from "@jskit-ai/database-runtime/shared/repositoryOptions";
 import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { runInTransaction } from "@jskit-ai/database-runtime/shared/repositoryOptions";
 import {
   parseJsonObject,
+  resolveInsertedId,
   stringifyJsonObject,
-  toIso,
-  resolveInsertedId
-} from "./repositoryPersistenceUtils.js";
+  toIso
+} from "@jskit-ai/assistant-core/server";
+import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
+
+function normalizeWorkspaceId(value) {
+  return parsePositiveInteger(value) || null;
+}
+
+function applyWorkspaceScope(query, columnName, workspaceId) {
+  const normalizedWorkspaceId = normalizeWorkspaceId(workspaceId);
+  if (normalizedWorkspaceId) {
+    return query.where(columnName, normalizedWorkspaceId);
+  }
+
+  return query.whereNull(columnName);
+}
 
 function mapMessageRow(row = {}) {
   return {
     id: Number(row.id),
     conversationId: Number(row.conversation_id),
-    workspaceId: Number(row.workspace_id),
+    workspaceId: normalizeWorkspaceId(row.workspace_id),
     seq: Number(row.seq),
     role: String(row.role || ""),
     kind: String(row.kind || "chat"),
@@ -35,7 +49,10 @@ function normalizePagination(pagination = {}, { defaultPage = 1, defaultPageSize
 }
 
 async function resolveNextSequence(client, conversationId) {
-  const row = await client("ai_messages").where({ conversation_id: conversationId }).max({ maxSeq: "seq" }).first();
+  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;
@@ -44,7 +61,7 @@ async function resolveNextSequence(client, conversationId) {
   return maxSeq + 1;
 }
 
-function createMessagesRepository(knex) {
+function createRepository(knex) {
   if (!knex || typeof knex !== "function") {
     throw new Error("createMessagesRepository requires knex client.");
   }
@@ -56,22 +73,24 @@ function createMessagesRepository(knex) {
     }
 
     const client = options?.trx || knex;
-    const row = await client("ai_messages").where({ id: numericMessageId }).first();
+    const row = await client(assistantRuntimeConfig.messagesTable)
+      .where({ id: numericMessageId })
+      .first();
+
     return row ? mapMessageRow(row) : null;
   }
 
   async function create(payload = {}, options = {}) {
     const client = options?.trx || knex;
     const conversationId = parsePositiveInteger(payload.conversationId);
-    const workspaceId = parsePositiveInteger(payload.workspaceId);
-    if (!conversationId || !workspaceId) {
-      throw new TypeError("messagesRepository.create requires conversationId and workspaceId.");
+    if (!conversationId) {
+      throw new TypeError("messagesRepository.create requires conversationId.");
     }
 
     const seq = parsePositiveInteger(payload.seq) || (await resolveNextSequence(client, conversationId));
-    const insertResult = await client("ai_messages").insert({
+    const insertResult = await client(assistantRuntimeConfig.messagesTable).insert({
       conversation_id: conversationId,
-      workspace_id: workspaceId,
+      workspace_id: normalizeWorkspaceId(payload.workspaceId),
       seq,
       role: normalizeText(payload.role).toLowerCase(),
       kind: normalizeText(payload.kind).toLowerCase() || "chat",
@@ -91,30 +110,26 @@ function createMessagesRepository(knex) {
     });
   }
 
-  async function countByConversationForWorkspace(conversationId, workspaceId, options = {}) {
+  async function countByConversationScope(conversationId, { workspaceId = null } = {}, options = {}) {
     const numericConversationId = parsePositiveInteger(conversationId);
-    const numericWorkspaceId = parsePositiveInteger(workspaceId);
-    if (!numericConversationId || !numericWorkspaceId) {
+    if (!numericConversationId) {
       return 0;
     }
 
     const client = options?.trx || knex;
-    const row = await client("ai_messages")
-      .where({
-        conversation_id: numericConversationId,
-        workspace_id: numericWorkspaceId
-      })
-      .count({ total: "*" })
-      .first();
+    const query = client(assistantRuntimeConfig.messagesTable).where({
+      conversation_id: numericConversationId
+    });
+    applyWorkspaceScope(query, "workspace_id", workspaceId);
+    const row = await query.count({ total: "*" }).first();
 
     const total = Number(row?.total || 0);
     return Number.isFinite(total) && total > 0 ? total : 0;
   }
 
-  async function listByConversationForWorkspace(conversationId, workspaceId, pagination = {}, options = {}) {
+  async function listByConversationScope(conversationId, { workspaceId = null } = {}, pagination = {}, options = {}) {
     const numericConversationId = parsePositiveInteger(conversationId);
-    const numericWorkspaceId = parsePositiveInteger(workspaceId);
-    if (!numericConversationId || !numericWorkspaceId) {
+    if (!numericConversationId) {
       return [];
     }
 
@@ -122,11 +137,11 @@ function createMessagesRepository(knex) {
     const { page, pageSize } = normalizePagination(pagination);
     const offset = (page - 1) * pageSize;
 
-    const rows = await client("ai_messages")
-      .where({
-        conversation_id: numericConversationId,
-        workspace_id: numericWorkspaceId
-      })
+    const query = client(assistantRuntimeConfig.messagesTable).where({
+      conversation_id: numericConversationId
+    });
+    applyWorkspaceScope(query, "workspace_id", workspaceId);
+    const rows = await query
       .orderBy("seq", "asc")
       .orderBy("id", "asc")
       .limit(pageSize)
@@ -142,10 +157,10 @@ function createMessagesRepository(knex) {
   return Object.freeze({
     findById,
     create,
-    countByConversationForWorkspace,
-    listByConversationForWorkspace,
+    countByConversationScope,
+    listByConversationScope,
     transaction
   });
 }
 
-export { createMessagesRepository as createRepository, createMessagesRepository };
+export { createRepository };

package/templates/src/local-package/server/services/assistantConfigService.js

@@ -0,0 +1,90 @@
+import { AppError, parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeObject } from "@jskit-ai/kernel/shared/support/normalize";
+import { resolveWorkspace } from "@jskit-ai/users-core/server/support/resolveWorkspace";
+import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
+
+function createService({ assistantConfigRepository, consoleService = null } = {}) {
+  if (!assistantConfigRepository || typeof assistantConfigRepository.findByScope !== "function") {
+    throw new Error("assistantConfigService requires assistantConfigRepository.findByScope().");
+  }
+  if (typeof assistantConfigRepository.upsertByScope !== "function") {
+    throw new Error("assistantConfigService requires assistantConfigRepository.upsertByScope().");
+  }
+  if (typeof assistantConfigRepository.createDefaultRecord !== "function") {
+    throw new Error("assistantConfigService requires assistantConfigRepository.createDefaultRecord().");
+  }
+  if (
+    assistantRuntimeConfig.settingsSurfaceRequiresConsoleOwner &&
+    (!consoleService || typeof consoleService.requireConsoleOwner !== "function")
+  ) {
+    throw new Error("assistantConfigService requires consoleService.requireConsoleOwner() for console-owner settings surfaces.");
+  }
+
+  async function requireSettingsAccess(context = {}, options = {}) {
+    if (assistantRuntimeConfig.settingsSurfaceRequiresConsoleOwner !== true) {
+      return;
+    }
+
+    await consoleService.requireConsoleOwner(context, options);
+  }
+
+  function resolveConfigWorkspaceId(workspace = null, input = {}, context = {}) {
+    if (assistantRuntimeConfig.configScope !== "workspace") {
+      return null;
+    }
+
+    const resolvedWorkspace = workspace || resolveWorkspace(context, input);
+    const workspaceId = parsePositiveInteger(resolvedWorkspace?.id);
+    if (!workspaceId) {
+      throw new AppError(409, "Workspace selection required.");
+    }
+
+    return workspaceId;
+  }
+
+  async function getSettings(input = {}, options = {}) {
+    await requireSettingsAccess(options?.context, options);
+
+    const workspaceId = resolveConfigWorkspaceId(null, input, options?.context);
+    const existing = await assistantConfigRepository.findByScope({
+      targetSurfaceId: assistantRuntimeConfig.runtimeSurfaceId,
+      workspaceId
+    });
+
+    return existing || assistantConfigRepository.createDefaultRecord({
+      targetSurfaceId: assistantRuntimeConfig.runtimeSurfaceId,
+      workspaceId
+    });
+  }
+
+  async function updateSettings(input = {}, patch = {}, options = {}) {
+    await requireSettingsAccess(options?.context, options);
+
+    const workspaceId = resolveConfigWorkspaceId(null, input, options?.context);
+    const normalizedPatch = normalizeObject(patch);
+
+    return assistantConfigRepository.upsertByScope({
+      targetSurfaceId: assistantRuntimeConfig.runtimeSurfaceId,
+      workspaceId,
+      patch: normalizedPatch
+    });
+  }
+
+  async function resolveSystemPrompt(workspace = null, _options = {}, serviceOptions = {}) {
+    const workspaceId = resolveConfigWorkspaceId(workspace, serviceOptions?.input || {}, serviceOptions?.context);
+    const existing = await assistantConfigRepository.findByScope({
+      targetSurfaceId: assistantRuntimeConfig.runtimeSurfaceId,
+      workspaceId
+    });
+
+    return String(existing?.settings?.systemPrompt || "");
+  }
+
+  return Object.freeze({
+    getSettings,
+    updateSettings,
+    resolveSystemPrompt
+  });
+}
+
+export { createService };