@jskit-ai/assistant 0.1.32 → 0.1.35

package/src/server/registerRoutes.js

@@ -1,383 +0,0 @@
-import { withStandardErrorResponses } from "@jskit-ai/http-runtime/shared/validators/errorResponses";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import {
-  workspaceSlugParamsValidator
-} from "@jskit-ai/users-core/server/validators/routeParamsValidator";
-import {
-  resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig,
-  resolveWorkspaceSurfaceIdsFromAppConfig
-} from "@jskit-ai/users-core/server/support/workspaceActionSurfaces";
-import { resolveAssistantApiBasePath } from "../shared/assistantPaths.js";
-import { assistantResource } from "../shared/assistantResource.js";
-import {
-  assistantConsoleSettingsResource,
-  assistantWorkspaceSettingsResource
-} from "../shared/assistantSettingsResource.js";
-import { actionIds } from "./actionIds.js";
-import { endNdjson, mapStreamError, setNdjsonHeaders, writeNdjson } from "./lib/ndjson.js";
-
-function resolveAssistantWorkspaceRouteSurfaceConfig(app) {
-  const appConfig = typeof app?.has === "function" && app.has("appConfig") ? app.make("appConfig") : {};
-  const workspaceSurfaceIds = resolveWorkspaceSurfaceIdsFromAppConfig(appConfig);
-  const fallbackSurfaceId = resolveDefaultWorkspaceRouteSurfaceIdFromAppConfig(appConfig);
-  return Object.freeze({
-    fallbackSurfaceId,
-    allowedSurfaceIds: new Set(workspaceSurfaceIds)
-  });
-}
-
-function resolveAssistantWorkspaceRequestSurfaceId(request, workspaceRouteSurfaceConfig = {}) {
-  const headerValue = request?.headers?.["x-jskit-surface"];
-  const headerCandidate = Array.isArray(headerValue) ? headerValue[0] : headerValue;
-  const requestedSurfaceId = normalizeText(headerCandidate).toLowerCase();
-  const fallbackSurfaceId = normalizeText(workspaceRouteSurfaceConfig?.fallbackSurfaceId).toLowerCase() || "app";
-  const allowedSurfaceIds = workspaceRouteSurfaceConfig?.allowedSurfaceIds instanceof Set
-    ? workspaceRouteSurfaceConfig.allowedSurfaceIds
-    : new Set();
-
-  if (!requestedSurfaceId) {
-    return fallbackSurfaceId;
-  }
-  if (allowedSurfaceIds.size > 0 && !allowedSurfaceIds.has(requestedSurfaceId)) {
-    return fallbackSurfaceId;
-  }
-  return requestedSurfaceId;
-}
-
-function registerRoutes(app) {
-  if (!app || typeof app.make !== "function") {
-    throw new Error("registerRoutes requires application make().");
-  }
-
-  const router = app.make("jskit.http.router");
-  const visibility = "workspace";
-  const workspaceRouteSurfaceConfig = resolveAssistantWorkspaceRouteSurfaceConfig(app);
-  const workspaceRouteSurfaceId = workspaceRouteSurfaceConfig.fallbackSurfaceId;
-  const routeBase = resolveAssistantApiBasePath({
-    visibility
-  });
-
-  router.register(
-    "GET",
-    "/api/console/settings/assistant",
-    {
-      auth: "required",
-      surface: "console",
-      meta: {
-        tags: ["assistant", "settings"],
-        summary: "Get assistant console settings."
-      },
-      responseValidators: withStandardErrorResponses({
-        200: assistantConsoleSettingsResource.operations.view.outputValidator
-      })
-    },
-    async function assistantConsoleSettingsReadRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.consoleSettingsRead
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "PATCH",
-    "/api/console/settings/assistant",
-    {
-      auth: "required",
-      surface: "console",
-      meta: {
-        tags: ["assistant", "settings"],
-        summary: "Update assistant console settings."
-      },
-      bodyValidator: assistantConsoleSettingsResource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: assistantConsoleSettingsResource.operations.patch.outputValidator
-        },
-        {
-          includeValidation400: true
-        }
-      )
-    },
-    async function assistantConsoleSettingsPatchRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.consoleSettingsUpdate,
-        input: {
-          payload: request.input.body
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "GET",
-    "/api/w/:workspaceSlug/settings/assistant",
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility,
-      meta: {
-        tags: ["assistant", "settings"],
-        summary: "Get assistant workspace settings."
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      responseValidators: withStandardErrorResponses({
-        200: assistantWorkspaceSettingsResource.operations.view.outputValidator
-      })
-    },
-    async function assistantWorkspaceSettingsReadRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.workspaceSettingsRead,
-        context: {
-          surface: resolveAssistantWorkspaceRequestSurfaceId(request, workspaceRouteSurfaceConfig)
-        },
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "PATCH",
-    "/api/w/:workspaceSlug/settings/assistant",
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility,
-      meta: {
-        tags: ["assistant", "settings"],
-        summary: "Update assistant workspace settings."
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      bodyValidator: assistantWorkspaceSettingsResource.operations.patch.bodyValidator,
-      responseValidators: withStandardErrorResponses(
-        {
-          200: assistantWorkspaceSettingsResource.operations.patch.outputValidator
-        },
-        {
-          includeValidation400: true
-        }
-      )
-    },
-    async function assistantWorkspaceSettingsPatchRoute(request, reply) {
-      const response = await request.executeAction({
-        actionId: actionIds.workspaceSettingsUpdate,
-        context: {
-          surface: resolveAssistantWorkspaceRequestSurfaceId(request, workspaceRouteSurfaceConfig)
-        },
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug,
-          patch: request.input.body
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "POST",
-    `${routeBase}/chat/stream`,
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility,
-      meta: {
-        tags: ["assistant"],
-        summary: "Stream assistant response for workspace user."
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      bodyValidator: assistantResource.operations.chatStream.bodyValidator
-    },
-    async function assistantChatStreamRoute(request, reply) {
-      const abortController = new AbortController();
-      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,
-          context: {
-            surface: resolveAssistantWorkspaceRequestSurfaceId(request, workspaceRouteSurfaceConfig)
-          },
-          input: (() => {
-            const body = request.input.body;
-            const input = {
-              workspaceSlug: request.input.params.workspaceSlug,
-              messageId: body.messageId,
-              input: body.input
-            };
-            if (Object.hasOwn(body, "conversationId")) {
-              input.conversationId = body.conversationId;
-            }
-            if (Object.hasOwn(body, "history")) {
-              input.history = body.history;
-            }
-            if (Object.hasOwn(body, "clientContext")) {
-              input.clientContext = body.clientContext;
-            }
-            return input;
-          })(),
-          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",
-    `${routeBase}/conversations`,
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility,
-      meta: {
-        tags: ["assistant"],
-        summary: "List assistant conversations for current workspace user."
-      },
-      paramsValidator: workspaceSlugParamsValidator,
-      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,
-        context: {
-          surface: resolveAssistantWorkspaceRequestSurfaceId(request, workspaceRouteSurfaceConfig)
-        },
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug,
-          query: request.input.query
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-
-  router.register(
-    "GET",
-    `${routeBase}/conversations/:conversationId/messages`,
-    {
-      auth: "required",
-      surface: workspaceRouteSurfaceId,
-      visibility,
-      meta: {
-        tags: ["assistant"],
-        summary: "List messages for one assistant conversation."
-      },
-      paramsValidator: [workspaceSlugParamsValidator, 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,
-        context: {
-          surface: resolveAssistantWorkspaceRequestSurfaceId(request, workspaceRouteSurfaceConfig)
-        },
-        input: {
-          workspaceSlug: request.input.params.workspaceSlug,
-          conversationId: request.input.params.conversationId,
-          query: request.input.query
-        }
-      });
-
-      reply.code(200).send(response);
-    }
-  );
-}
-
-export { registerRoutes };

package/src/server/repositories/assistantSettingsRepository.js

@@ -1,100 +0,0 @@
-import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
-import { toIso } from "./repositoryPersistenceUtils.js";
-
-function mapConsoleRow(row = {}) {
-  return {
-    workspaceSurfacePrompt: String(row.assistant_workspace_surface_prompt || ""),
-    createdAt: toIso(row.created_at),
-    updatedAt: toIso(row.updated_at)
-  };
-}
-
-function mapWorkspaceRow(row = {}) {
-  return {
-    workspaceId: Number(row.workspace_id),
-    appSurfacePrompt: String(row.assistant_app_surface_prompt || ""),
-    createdAt: toIso(row.created_at),
-    updatedAt: toIso(row.updated_at)
-  };
-}
-
-function createRepository(knex) {
-  if (typeof knex !== "function") {
-    throw new TypeError("assistantSettingsRepository requires knex.");
-  }
-
-  async function ensureConsoleSettings(options = {}) {
-    const client = options?.trx || knex;
-    const row = await client("console_settings").where({ id: 1 }).first();
-    if (!row) {
-      throw new Error("console_settings row missing.");
-    }
-
-    return mapConsoleRow(row);
-  }
-
-  async function updateConsoleSettings(patch = {}, options = {}) {
-    const client = options?.trx || knex;
-    const nextWorkspaceSurfacePrompt = String(patch.workspaceSurfacePrompt || "");
-
-    await client("console_settings")
-      .where({ id: 1 })
-      .update({
-        assistant_workspace_surface_prompt: nextWorkspaceSurfacePrompt,
-        updated_at: new Date()
-      });
-
-    return ensureConsoleSettings({
-      trx: client
-    });
-  }
-
-  async function ensureWorkspaceSettings(workspaceId, options = {}) {
-    const numericWorkspaceId = parsePositiveInteger(workspaceId);
-    if (!numericWorkspaceId) {
-      throw new TypeError("assistantSettingsRepository.ensureWorkspaceSettings requires workspace id.");
-    }
-
-    const client = options?.trx || knex;
-    const row = await client("workspace_settings").where({ workspace_id: numericWorkspaceId }).first();
-    if (!row) {
-      throw new Error("workspace_settings row missing.");
-    }
-
-    return mapWorkspaceRow(row);
-  }
-
-  async function updateWorkspaceSettings(workspaceId, patch = {}, options = {}) {
-    const numericWorkspaceId = parsePositiveInteger(workspaceId);
-    if (!numericWorkspaceId) {
-      throw new TypeError("assistantSettingsRepository.updateWorkspaceSettings requires workspace id.");
-    }
-
-    const client = options?.trx || knex;
-    const nextAppSurfacePrompt = String(patch.appSurfacePrompt || "");
-
-    await ensureWorkspaceSettings(numericWorkspaceId, {
-      trx: client
-    });
-
-    await client("workspace_settings")
-      .where({ workspace_id: numericWorkspaceId })
-      .update({
-        assistant_app_surface_prompt: nextAppSurfacePrompt,
-        updated_at: new Date()
-      });
-
-    return ensureWorkspaceSettings(numericWorkspaceId, {
-      trx: client
-    });
-  }
-
-  return Object.freeze({
-    ensureConsoleSettings,
-    updateConsoleSettings,
-    ensureWorkspaceSettings,
-    updateWorkspaceSettings
-  });
-}
-
-export { createRepository };

package/src/server/repositories/repositoryPersistenceUtils.js

@@ -1,48 +0,0 @@
-import { parseJsonObject } from "../../shared/support/jsonObject.js";
-
-function stringifyJsonObject(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-
-  return JSON.stringify(value);
-}
-
-function toIso(value) {
-  if (!value) {
-    return "";
-  }
-
-  const date = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    return "";
-  }
-
-  return date.toISOString();
-}
-
-function resolveInsertedId(insertResult) {
-  if (Array.isArray(insertResult) && insertResult.length > 0) {
-    const first = insertResult[0];
-    if (first && typeof first === "object" && !Array.isArray(first)) {
-      const objectId = Number(first.id);
-      if (Number.isInteger(objectId) && objectId > 0) {
-        return objectId;
-      }
-    }
-
-    const scalarId = Number(first);
-    if (Number.isInteger(scalarId) && scalarId > 0) {
-      return scalarId;
-    }
-  }
-
-  const directId = Number(insertResult);
-  if (Number.isInteger(directId) && directId > 0) {
-    return directId;
-  }
-
-  return 0;
-}
-
-export { parseJsonObject, stringifyJsonObject, toIso, resolveInsertedId };

package/src/server/services/assistantSettingsService.js

@@ -1,149 +0,0 @@
-import { parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators";
-import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { pickOwnProperties } from "@jskit-ai/kernel/shared/support";
-
-const serviceEvents = Object.freeze({
-  updateConsoleSettings: Object.freeze([
-    Object.freeze({
-      type: "entity.changed",
-      source: "assistant",
-      entity: "console.settings",
-      operation: "updated",
-      entityId: 1,
-      realtime: Object.freeze({
-        event: "assistant.console.settings.changed",
-        audience: "all_users"
-      })
-    })
-  ]),
-  updateWorkspaceSettings: Object.freeze([
-    Object.freeze({
-      type: "entity.changed",
-      source: "assistant",
-      entity: "workspace.settings",
-      operation: "updated",
-      entityId: ({ args }) => args?.[0]?.id || null,
-      realtime: Object.freeze({
-        event: "assistant.workspace.settings.changed",
-        audience: "event_scope",
-        payload: ({ args }) => ({
-          workspaceSlug: String(args?.[0]?.slug || "").trim()
-        })
-      })
-    })
-  ])
-});
-
-function normalizeSurface(value) {
-  return normalizeText(value).toLowerCase();
-}
-
-function mapConsoleResponse(record = {}) {
-  return {
-    settings: {
-      workspaceSurfacePrompt: String(record.workspaceSurfacePrompt || "")
-    }
-  };
-}
-
-function mapWorkspaceResponse(record = {}) {
-  return {
-    settings: {
-      appSurfacePrompt: String(record.appSurfacePrompt || "")
-    }
-  };
-}
-
-function createService({ assistantSettingsRepository, consoleService } = {}) {
-  if (!assistantSettingsRepository || typeof assistantSettingsRepository.ensureConsoleSettings !== "function") {
-    throw new Error("assistantSettingsService requires assistantSettingsRepository.ensureConsoleSettings().");
-  }
-  if (!assistantSettingsRepository || typeof assistantSettingsRepository.ensureWorkspaceSettings !== "function") {
-    throw new Error("assistantSettingsService requires assistantSettingsRepository.ensureWorkspaceSettings().");
-  }
-  if (!assistantSettingsRepository || typeof assistantSettingsRepository.updateConsoleSettings !== "function") {
-    throw new Error("assistantSettingsService requires assistantSettingsRepository.updateConsoleSettings().");
-  }
-  if (!assistantSettingsRepository || typeof assistantSettingsRepository.updateWorkspaceSettings !== "function") {
-    throw new Error("assistantSettingsService requires assistantSettingsRepository.updateWorkspaceSettings().");
-  }
-  if (!consoleService || typeof consoleService.requireConsoleOwner !== "function") {
-    throw new Error("assistantSettingsService requires consoleService.requireConsoleOwner().");
-  }
-
-  async function getConsoleSettings(options = {}) {
-    await consoleService.requireConsoleOwner(options?.context, options);
-    const settings = await assistantSettingsRepository.ensureConsoleSettings(options);
-    return mapConsoleResponse(settings);
-  }
-
-  async function updateConsoleSettings(payload = {}, options = {}) {
-    await consoleService.requireConsoleOwner(options?.context, options);
-    const source = normalizeObjectInput(payload);
-    const patch = pickOwnProperties(source, ["workspaceSurfacePrompt"]);
-    if (Object.keys(patch).length < 1) {
-      const settings = await assistantSettingsRepository.ensureConsoleSettings(options);
-      return mapConsoleResponse(settings);
-    }
-    const settings = await assistantSettingsRepository.updateConsoleSettings({
-      workspaceSurfacePrompt: String(patch.workspaceSurfacePrompt || "")
-    }, options);
-    return mapConsoleResponse(settings);
-  }
-
-  async function getWorkspaceSettings(workspace, options = {}) {
-    const workspaceId = parsePositiveInteger(workspace?.id);
-    if (!workspaceId) {
-      throw new Error("assistantSettingsService.getWorkspaceSettings requires workspace.id.");
-    }
-
-    const settings = await assistantSettingsRepository.ensureWorkspaceSettings(workspaceId, options);
-    return mapWorkspaceResponse(settings);
-  }
-
-  async function updateWorkspaceSettings(workspace, payload = {}, options = {}) {
-    const workspaceId = parsePositiveInteger(workspace?.id);
-    if (!workspaceId) {
-      throw new Error("assistantSettingsService.updateWorkspaceSettings requires workspace.id.");
-    }
-
-    const source = normalizeObjectInput(payload);
-    const patch = pickOwnProperties(source, ["appSurfacePrompt"]);
-    if (Object.keys(patch).length < 1) {
-      const settings = await assistantSettingsRepository.ensureWorkspaceSettings(workspaceId, options);
-      return mapWorkspaceResponse(settings);
-    }
-    const settings = await assistantSettingsRepository.updateWorkspaceSettings(
-      workspaceId,
-      {
-        appSurfacePrompt: String(patch.appSurfacePrompt || "")
-      },
-      options
-    );
-
-    return mapWorkspaceResponse(settings);
-  }
-
-  async function resolveSystemPrompt(workspace, { surface = "" } = {}, options = {}) {
-    const normalizedSurface = normalizeSurface(surface);
-
-    if (normalizedSurface === "app") {
-      const workspaceSettings = await getWorkspaceSettings(workspace, options);
-      return String(workspaceSettings?.settings?.appSurfacePrompt || "");
-    }
-
-    const consoleSettings = await assistantSettingsRepository.ensureConsoleSettings(options);
-    return String(consoleSettings.workspaceSurfacePrompt || "");
-  }
-
-  return Object.freeze({
-    getConsoleSettings,
-    updateConsoleSettings,
-    getWorkspaceSettings,
-    updateWorkspaceSettings,
-    resolveSystemPrompt
-  });
-}
-
-export { createService, serviceEvents };