@jskit-ai/assistant-runtime 0.2.29 → 0.2.31

package/src/server/repositories/assistantConfigRepository.js

@@ -1,8 +1,6 @@
-import { createWithTransaction } from "@jskit-ai/database-runtime/shared";
 import { normalizeSurfaceId } from "@jskit-ai/kernel/shared/surface/registry";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { normalizeDbWorkspaceId, normalizeInputRecordId, resolveInsertedId } from "./repositoryPersistenceUtils.js";
-import { assistantRuntimeConfig } from "../../shared/assistantRuntimeConfig.js";
+import { normalizeInputRecordId, toWrittenDateTime } from "./repositoryPersistenceUtils.js";
 
 function normalizeTargetSurfaceId(value = "") {
   return normalizeSurfaceId(value);
@@ -21,13 +19,13 @@ function buildScopeKey(targetSurfaceId, workspaceId = null) {
   return `${normalizedTargetSurfaceId}:global`;
 }
 
-function mapConfigRow(row = {}) {
+function mapConfigRecord(record = {}) {
   return {
-    targetSurfaceId: normalizeTargetSurfaceId(row.target_surface_id),
-    scopeKey: normalizeText(row.scope_key),
-    workspaceId: normalizeDbWorkspaceId(row.workspace_id),
+    targetSurfaceId: normalizeTargetSurfaceId(record.targetSurfaceId),
+    scopeKey: normalizeText(record.scopeKey),
+    workspaceId: normalizeInputRecordId(record.workspaceId),
     settings: {
-      systemPrompt: String(row.system_prompt || "")
+      systemPrompt: String(record.systemPrompt || "")
     }
   };
 }
@@ -49,51 +47,56 @@ function createDefaultRecord({ targetSurfaceId = "", workspaceId = null } = {})
   };
 }
 
-/** @param {import("@jskit-ai/database-runtime/server/types").RuntimeKnex} knex */
-function createRepository(knex) {
-  const withTransaction = createWithTransaction(knex);
+/**
+ * The saved settings of each assistant surface and scope, on the assistantConfig table.
+ * @param {object} dependencies
+ * @param {import("@jskit-ai/resource-runtime/server/types").ResourceHandle} dependencies.assistantConfig
+ * @param {(reason: string) => import("@jskit-ai/resource-runtime/server/types").SystemContext} dependencies.systemContext
+ */
+function createRepository({ assistantConfig, systemContext }) {
+  const settingsContext = systemContext("global assistant settings are shared by every workspace, so they are read and written outside one");
+
+  // A workspace's settings are read and written in that workspace; global settings in the system context.
+  function scoped(workspaceId, options) {
+    return { ...options, context: workspaceId ? settingsContext.forWorkspace(workspaceId) : settingsContext };
+  }
+
+  function withTransaction(options, work) {
+    return assistantConfig.withTransaction(options, work);
+  }
+
+  async function findRecord(defaultRecord, options) {
+    const { records } = await assistantConfig.query({
+      filters: {
+        targetSurfaceId: defaultRecord.targetSurfaceId,
+        scopeKey: defaultRecord.scopeKey
+      },
+      page: { size: 1 }
+    }, scoped(defaultRecord.workspaceId, options));
+    return records[0] || null;
+  }
 
   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;
+    const record = await findRecord(createDefaultRecord({ targetSurfaceId, workspaceId }), options);
+    return record ? mapConfigRecord(record) : 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 existing = await findRecord(defaultRecord, options);
     const nextSystemPrompt = Object.hasOwn(patch, "systemPrompt")
       ? String(patch.systemPrompt || "")
-      : String(existing?.settings?.systemPrompt || defaultRecord.settings.systemPrompt);
-    const now = new Date();
+      : String(existing?.systemPrompt || defaultRecord.settings.systemPrompt);
+    const now = toWrittenDateTime();
 
     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
-        });
+      await assistantConfig.patch(existing.id, {
+        systemPrompt: nextSystemPrompt,
+        updatedAt: now
+      }, { ...scoped(defaultRecord.workspaceId, options), missing: "skip", returning: "none" });
 
       return {
         ...defaultRecord,
@@ -103,34 +106,16 @@ function createRepository(knex) {
       };
     }
 
-    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();
+    const created = await assistantConfig.create({
+      targetSurfaceId: defaultRecord.targetSurfaceId,
+      scopeKey: defaultRecord.scopeKey,
+      workspaceId: defaultRecord.workspaceId,
+      systemPrompt: nextSystemPrompt,
+      createdAt: now,
+      updatedAt: now
+    }, scoped(defaultRecord.workspaceId, options));
 
-    return insertedRow ? mapConfigRow(insertedRow) : {
-      ...defaultRecord,
-      settings: {
-        systemPrompt: nextSystemPrompt
-      }
-    };
+    return mapConfigRecord(created);
   }
 
   return Object.freeze({

package/src/server/repositories/assistantResources.js

@@ -0,0 +1,119 @@
+import { defineTableResource } from "@jskit-ai/resource-core/shared/tableResource";
+
+// The assistant's four tables. The repositories normalize every value before
+// they write it, so text is stored exactly as given (noTrim), and dates are
+// written as UTC database date-times. Each declares the foreign keys its
+// migrations always create; the workspace_id keys exist only where the
+// application has a workspaces table (constraints/assistant_workspaces_foreign_keys.cjs),
+// so none declares them.
+
+/** @param {Record<string, unknown>} [definition] */
+function textField(definition = {}) {
+  return { type: "string", noTrim: true, ...definition };
+}
+
+/** @param {Record<string, unknown>} [definition] */
+function dateTimeField(definition = {}) {
+  return { type: "dateTime", storage: { writeSerializer: "datetime-utc" }, ...definition };
+}
+
+// A surface's saved settings: one row per surface and scope. Global settings
+// (workspaceId null) are shared by every workspace.
+const assistantConfigResource = defineTableResource({
+  name: "assistantConfig",
+  tableName: "assistant_config",
+  ownership: "workspace_or_shared",
+  schema: {
+    targetSurfaceId: textField({ search: true }),
+    scopeKey: textField({ search: true }),
+    workspaceId: { type: "id", nullable: true, search: true },
+    systemPrompt: textField(),
+    createdAt: dateTimeField(),
+    updatedAt: dateTimeField()
+  }
+});
+
+// A conversation belongs to the user who started it (created_by_user_id); its
+// workspace (null for a global surface) and surface are filters of its actor scope.
+const assistantConversationsResource = defineTableResource({
+  name: "assistantConversations",
+  tableName: "assistant_conversations",
+  ownership: "user",
+  foreignKeys: [{ columns: ["userId"], referencedTableName: "users" }],
+  queryMaxLimit: 200,
+  schema: {
+    workspaceId: { type: "id", nullable: true, search: true },
+    userId: { type: "id", nullable: true, search: true, storage: { column: "created_by_user_id" } },
+    title: textField(),
+    status: textField({ search: true }),
+    provider: textField(),
+    model: textField(),
+    surfaceId: textField({ search: true }),
+    messageCount: { type: "integer" },
+    metadataJson: textField({ nullable: true }),
+    startedAt: dateTimeField(),
+    endedAt: dateTimeField({ nullable: true }),
+    createdAt: dateTimeField(),
+    updatedAt: dateTimeField(),
+    summaryText: textField({ nullable: true }),
+    summaryThroughTurnId: textField({ nullable: true }),
+    transcriptRevision: textField({ nullable: true })
+  },
+  searchSchema: {
+    beforeId: { type: "id", actualField: "id", filterOperator: "<" }
+  }
+});
+
+// A conversation's messages, in seq order, with the conversation's workspace.
+const assistantMessagesResource = defineTableResource({
+  name: "assistantMessages",
+  tableName: "assistant_messages",
+  ownership: "workspace",
+  foreignKeys: [
+    { columns: ["conversationId"], referencedTableName: "assistant_conversations" },
+    { columns: ["actorUserId"], referencedTableName: "users" }
+  ],
+  queryMaxLimit: 500,
+  schema: {
+    conversationId: { type: "id", search: true },
+    workspaceId: { type: "id", nullable: true, search: true },
+    seq: { type: "integer" },
+    role: textField({ search: true }),
+    kind: textField({ search: true }),
+    clientMessageSid: textField(),
+    actorUserId: { type: "id", nullable: true },
+    contentText: textField({ nullable: true }),
+    metadataJson: textField({ nullable: true }),
+    createdAt: dateTimeField()
+  },
+  searchSchema: {
+    conversationIds: { type: "array", actualField: "conversationId", filterOperator: "in", items: { type: "string" } }
+  }
+});
+
+// The receipt of one chat request, keyed by its actor, surface and workspace
+// scope, and the client's message id.
+const assistantTurnRequestsResource = defineTableResource({
+  name: "assistantTurnRequests",
+  tableName: "assistant_turn_requests",
+  ownership: "user",
+  foreignKeys: [{ columns: ["userId"], referencedTableName: "users" }],
+  schema: {
+    userId: { type: "id", search: true, storage: { column: "actor_user_id" } },
+    scopeKey: textField({ search: true }),
+    messageSid: textField({ search: true }),
+    claimToken: textField(),
+    requestJson: textField(),
+    responseJson: textField({ nullable: true }),
+    status: textField(),
+    createdAt: dateTimeField(),
+    updatedAt: dateTimeField()
+  }
+});
+
+export {
+  assistantConfigResource,
+  assistantConversationsResource,
+  assistantMessagesResource,
+  assistantTurnRequestsResource
+};