@jskit-ai/assistant 0.1.37 → 0.1.39

package/templates/src/local-package/server/registerRoutes.js

@@ -1,296 +0,0 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
-import { buildWorkspaceInputFromRouteParams } from "@jskit-ai/users-core/server/support/workspaceRouteInput";
-import { workspaceSlugParamsValidator } from "@jskit-ai/users-core/server/validators/routeParamsValidator";
-import {
-  assistantConfigResource,
-  assistantResource,
-  resolveAssistantApiBasePath,
-  resolveAssistantSettingsApiPath
-} from "@jskit-ai/assistant-core/shared";
-import {
-  endNdjson,
-  mapStreamError,
-  setNdjsonHeaders,
-  writeNdjson
-} from "@jskit-ai/assistant-core/server";
-import { assistantRuntimeConfig } from "../shared/assistantRuntimeConfig.js";
-import { actionIds } from "./actionIds.js";
-
-const runtimeVisibility = assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace ? "workspace" : "public";
-const settingsVisibility = assistantRuntimeConfig.settingsSurfaceRequiresWorkspace ? "workspace" : "public";
-const runtimeRouteBase = resolveAssistantApiBasePath({
-  requiresWorkspace: assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace
-});
-const settingsRouteBase = resolveAssistantSettingsApiPath({
-  requiresWorkspace: assistantRuntimeConfig.settingsSurfaceRequiresWorkspace
-});
-
-function buildWorkspaceRouteConfig(requiresWorkspace, baseConfig = {}) {
-  if (requiresWorkspace !== true) {
-    return baseConfig;
-  }
-
-  return {
-    ...baseConfig,
-    paramsValidator: workspaceSlugParamsValidator
-  };
-}
-
-function readWorkspaceInput(request, requiresWorkspace) {
-  if (requiresWorkspace !== true) {
-    return {};
-  }
-
-  return buildWorkspaceInputFromRouteParams(request?.input?.params);
-}
-
-function registerRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("registerRoutes requires application make().");
-  }
-
-  const router = app.make("jskit.http.router");
-
-  router.register(
-    "GET",
-    settingsRouteBase,
-    buildWorkspaceRouteConfig(assistantRuntimeConfig.settingsSurfaceRequiresWorkspace, {
-      auth: "required",
-      surface: assistantRuntimeConfig.settingsSurfaceId,
-      visibility: settingsVisibility,
-      meta: {
-        tags: ["assistant", "settings"],
-        summary: "Get assistant settings."
-      },
-      responseValidators: withStandardErrorResponses({
-        200: assistantConfigResource.operations.view.outputValidator
-      })
-    }),
-    async function assistantSettingsReadRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.settingsRead,
-        input: {
-          ...readWorkspaceInput(request, assistantRuntimeConfig.settingsSurfaceRequiresWorkspace)
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "PATCH",
-    settingsRouteBase,
-    buildWorkspaceRouteConfig(assistantRuntimeConfig.settingsSurfaceRequiresWorkspace, {
-      auth: "required",
-      surface: assistantRuntimeConfig.settingsSurfaceId,
-      visibility: settingsVisibility,
-      meta: {
-        tags: ["assistant", "settings"],
-        summary: "Update assistant settings."
-      },
-      bodyValidator: assistantConfigResource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: assistantConfigResource.operations.patch.outputValidator
-        },
-        {
-          includeValidation400: true
-        }
-      )
-    }),
-    async function assistantSettingsPatchRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.settingsUpdate,
-        input: {
-          ...readWorkspaceInput(request, assistantRuntimeConfig.settingsSurfaceRequiresWorkspace),
-          patch: request.input.body
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "POST",
-    `${runtimeRouteBase}/chat/stream`,
-    buildWorkspaceRouteConfig(assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace, {
-      auth: "required",
-      surface: assistantRuntimeConfig.runtimeSurfaceId,
-      visibility: runtimeVisibility,
-      meta: {
-        tags: ["assistant"],
-        summary: "Stream assistant response."
-      },
-      bodyValidator: assistantResource.operations.chatStream.bodyValidator
-    }),
-    async function assistantChatStreamRoute(request, reply) {
-      const abortController = new AbortController();
-      const requestBody = request?.input?.body && typeof request.input.body === "object" ? request.input.body : {};
-      const closeListener = () => {
-        abortController.abort();
-      };
-
-      let streamStarted = false;
-
-      function ensureStreamStarted() {
-        if (streamStarted) {
-          return;
-        }
-
-        setNdjsonHeaders(reply);
-        reply.code(200);
-        reply.hijack();
-        if (typeof reply.raw.flushHeaders === "function") {
-          reply.raw.flushHeaders();
-        }
-        streamStarted = true;
-      }
-
-      const streamWriter = Object.freeze({
-        sendMeta(payload = {}) {
-          ensureStreamStarted();
-          writeNdjson(reply, payload);
-        },
-        sendAssistantDelta(payload = {}) {
-          ensureStreamStarted();
-          writeNdjson(reply, payload);
-        },
-        sendAssistantMessage(payload = {}) {
-          ensureStreamStarted();
-          writeNdjson(reply, payload);
-        },
-        sendToolCall(payload = {}) {
-          ensureStreamStarted();
-          writeNdjson(reply, payload);
-        },
-        sendToolResult(payload = {}) {
-          ensureStreamStarted();
-          writeNdjson(reply, payload);
-        },
-        sendError(payload = {}) {
-          ensureStreamStarted();
-          writeNdjson(reply, payload);
-        },
-        sendDone(payload = {}) {
-          ensureStreamStarted();
-          writeNdjson(reply, payload);
-        }
-      });
-
-      try {
-        request.raw.on("close", closeListener);
-
-        await request.executeAction({
-          actionId: actionIds.chatStream,
-          input: {
-            ...readWorkspaceInput(request, assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace),
-            messageId: requestBody.messageId,
-            conversationId: requestBody.conversationId,
-            input: requestBody.input,
-            history: requestBody.history,
-            clientContext: requestBody.clientContext
-          },
-          deps: {
-            streamWriter,
-            abortSignal: abortController.signal
-          }
-        });
-
-        if (streamStarted) {
-          endNdjson(reply);
-          return;
-        }
-
-        reply.code(204).send();
-      } catch (error) {
-        if (!streamStarted) {
-          const statusCode = Number(error?.status || error?.statusCode || 500);
-          const safeStatusCode = Number.isInteger(statusCode) && statusCode >= 400 && statusCode <= 599 ? statusCode : 500;
-          reply.code(safeStatusCode).send({
-            error: safeStatusCode >= 500 ? "Internal server error." : String(error?.message || "Request failed.")
-          });
-          return;
-        }
-
-        const streamError = mapStreamError(error);
-        writeNdjson(reply, {
-          type: "error",
-          ...streamError
-        });
-        writeNdjson(reply, {
-          type: "done",
-          status: "failed"
-        });
-        endNdjson(reply);
-      } finally {
-        request.raw.off("close", closeListener);
-      }
-    }
-  );
-
-  router.register(
-    "GET",
-    `${runtimeRouteBase}/conversations`,
-    buildWorkspaceRouteConfig(assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace, {
-      auth: "required",
-      surface: assistantRuntimeConfig.runtimeSurfaceId,
-      visibility: runtimeVisibility,
-      meta: {
-        tags: ["assistant"],
-        summary: "List assistant conversations."
-      },
-      queryValidator: assistantResource.operations.conversationsList.queryValidator,
-      responseValidators: withStandardErrorResponses({
-        200: assistantResource.operations.conversationsList.outputValidator
-      })
-    }),
-    async function assistantConversationsRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.conversationsList,
-        input: {
-          ...readWorkspaceInput(request, assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace),
-          query: request.input.query
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "GET",
-    `${runtimeRouteBase}/conversations/:conversationId/messages`,
-    buildWorkspaceRouteConfig(assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace, {
-      auth: "required",
-      surface: assistantRuntimeConfig.runtimeSurfaceId,
-      visibility: runtimeVisibility,
-      meta: {
-        tags: ["assistant"],
-        summary: "List assistant conversation messages."
-      },
-      paramsValidator: assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace
-        ? [workspaceSlugParamsValidator, assistantResource.operations.conversationMessagesList.paramsValidator]
-        : assistantResource.operations.conversationMessagesList.paramsValidator,
-      queryValidator: assistantResource.operations.conversationMessagesList.queryValidator,
-      responseValidators: withStandardErrorResponses({
-        200: assistantResource.operations.conversationMessagesList.outputValidator
-      })
-    }),
-    async function assistantConversationMessagesRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.conversationMessagesList,
-        input: {
-          ...readWorkspaceInput(request, assistantRuntimeConfig.runtimeSurfaceRequiresWorkspace),
-          conversationId: request.input.params.conversationId,
-          query: request.input.query
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-}
-
-export { registerRoutes };

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

@@ -1,141 +0,0 @@
-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/templates/src/local-package/server/repositories/conversationsRepository.js

@@ -1,240 +0,0 @@
-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 {
-  parseJsonObject,
-  resolveInsertedId,
-  stringifyJsonObject,
-  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: normalizeWorkspaceId(row.workspace_id),
-    title: String(row.title || "New conversation"),
-    createdByUserId: row.created_by_user_id == null ? null : Number(row.created_by_user_id),
-    status: String(row.status || "active"),
-    provider: String(row.provider || ""),
-    model: String(row.model || ""),
-    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),
-    metadata: parseJsonObject(row.metadata_json),
-    createdAt: toIso(row.created_at),
-    updatedAt: toIso(row.updated_at)
-  };
-}
-
-function normalizeCursorPagination(pagination = {}, { defaultLimit = 20, maxLimit = 200 } = {}) {
-  const cursor = parsePositiveInteger(pagination.cursor) || 0;
-  const limit = Math.max(1, Math.min(maxLimit, parsePositiveInteger(pagination.limit) || defaultLimit));
-
-  return {
-    cursor,
-    limit
-  };
-}
-
-function createConversationBaseQuery(client) {
-  return client(`${assistantRuntimeConfig.conversationsTable} as c`).select("c.*");
-}
-
-function createRepository(knex) {
-  if (!knex || typeof knex !== "function") {
-    throw new Error("createConversationsRepository requires knex client.");
-  }
-
-  async function findById(conversationId, options = {}) {
-    const numericConversationId = parsePositiveInteger(conversationId);
-    if (!numericConversationId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const row = await createConversationBaseQuery(client)
-      .where("c.id", numericConversationId)
-      .first();
-
-    return row ? mapConversationRow(row) : null;
-  }
-
-  async function findByIdForActorScope(conversationId, { workspaceId = null, actorUserId = null } = {}, options = {}) {
-    const numericConversationId = parsePositiveInteger(conversationId);
-    const numericActorUserId = parsePositiveInteger(actorUserId);
-    if (!numericConversationId || !numericActorUserId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const query = createConversationBaseQuery(client)
-      .where("c.id", numericConversationId)
-      .where("c.created_by_user_id", numericActorUserId);
-    applyWorkspaceScope(query, "c.workspace_id", workspaceId);
-    const row = await query.first();
-
-    return row ? mapConversationRow(row) : null;
-  }
-
-  async function create(payload = {}, options = {}) {
-    const client = options?.trx || knex;
-    const now = new Date();
-    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_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,
-      ended_at: payload.endedAt ? new Date(payload.endedAt) : null,
-      created_at: now,
-      updated_at: now
-    });
-    const id = resolveInsertedId(insertResult);
-    if (!id) {
-      throw new Error("conversationsRepository.create could not resolve inserted id.");
-    }
-
-    return findById(id, {
-      trx: client
-    });
-  }
-
-  async function updateById(conversationId, patch = {}, options = {}) {
-    const numericConversationId = parsePositiveInteger(conversationId);
-    if (!numericConversationId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const updatePatch = {};
-
-    if (Object.hasOwn(patch, "title")) {
-      updatePatch.title = normalizeText(patch.title) || "New conversation";
-    }
-    if (Object.hasOwn(patch, "status")) {
-      updatePatch.status = normalizeText(patch.status).toLowerCase() || "active";
-    }
-    if (Object.hasOwn(patch, "provider")) {
-      updatePatch.provider = normalizeText(patch.provider);
-    }
-    if (Object.hasOwn(patch, "model")) {
-      updatePatch.model = normalizeText(patch.model);
-    }
-    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));
-    }
-    if (Object.hasOwn(patch, "endedAt")) {
-      updatePatch.ended_at = patch.endedAt ? new Date(patch.endedAt) : null;
-    }
-    if (Object.hasOwn(patch, "metadata")) {
-      updatePatch.metadata_json = stringifyJsonObject(patch.metadata);
-    }
-
-    if (Object.keys(updatePatch).length > 0) {
-      updatePatch.updated_at = new Date();
-      await client(assistantRuntimeConfig.conversationsTable)
-        .where({ id: numericConversationId })
-        .update(updatePatch);
-    }
-
-    return findById(numericConversationId, {
-      trx: client
-    });
-  }
-
-  async function incrementMessageCount(conversationId, delta = 1, options = {}) {
-    const numericConversationId = parsePositiveInteger(conversationId);
-    if (!numericConversationId) {
-      return null;
-    }
-
-    const client = options?.trx || knex;
-    const incrementBy = Number.isInteger(Number(delta)) ? Number(delta) : 1;
-    await client(assistantRuntimeConfig.conversationsTable)
-      .where({ id: numericConversationId })
-      .update({
-        message_count: client.raw("GREATEST(0, message_count + ?)", [incrementBy]),
-        updated_at: new Date()
-      });
-
-    return findById(numericConversationId, {
-      trx: client
-    });
-  }
-
-  async function listForActorScope({ workspaceId = null, actorUserId = null, pagination = {}, filters = {} } = {}, options = {}) {
-    const numericActorUserId = parsePositiveInteger(actorUserId);
-    if (!numericActorUserId) {
-      return {
-        items: [],
-        nextCursor: null
-      };
-    }
-
-    const client = options?.trx || knex;
-    const { cursor, limit } = normalizeCursorPagination(pagination);
-    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) {
-      query = query.where("c.status", normalizedStatus);
-    }
-    if (cursor > 0) {
-      query = query.where("c.id", "<", cursor);
-    }
-
-    const rows = await query
-      .orderBy("c.id", "desc")
-      .limit(limit + 1);
-
-    const hasMore = rows.length > limit;
-    const pageRows = hasMore ? rows.slice(0, limit) : rows;
-    const items = pageRows.map(mapConversationRow);
-    const nextCursor = hasMore && pageRows.length > 0 ? String(pageRows[pageRows.length - 1].id) : null;
-
-    return {
-      items,
-      nextCursor
-    };
-  }
-
-  async function transaction(callback) {
-    return runInTransaction(knex, callback);
-  }
-
-  return Object.freeze({
-    findById,
-    findByIdForActorScope,
-    create,
-    updateById,
-    incrementMessageCount,
-    listForActorScope,
-    transaction
-  });
-}
-
-export { createRepository };