@jskit-ai/assistant 0.1.4

package/src/server/services/transcriptService.js

@@ -0,0 +1,334 @@
+import { AppError, parsePositiveInteger } from "@jskit-ai/kernel/server/runtime";
+import { normalizeObject, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { ASSISTANT_TRANSCRIPT_CHANGED_EVENT } from "../../shared/streamEvents.js";
+
+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;
+
+const serviceEvents = Object.freeze({
+  createConversationForTurn: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "assistant",
+      entity: "conversation",
+      operation: ({ result }) => (result?.created === true ? "created" : "updated"),
+      entityId: ({ result }) => result?.conversation?.id,
+      realtime: Object.freeze({
+        event: ASSISTANT_TRANSCRIPT_CHANGED_EVENT,
+        audience: "event_scope",
+        payload: ({ result }) => ({
+          conversationId: result?.conversation?.id || null
+        })
+      })
+    })
+  ]),
+  appendMessage: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "assistant",
+      entity: "conversation",
+      operation: "updated",
+      entityId: ({ result }) => result?.conversationId,
+      realtime: Object.freeze({
+        event: ASSISTANT_TRANSCRIPT_CHANGED_EVENT,
+        audience: "event_scope",
+        payload: ({ result }) => ({
+          conversationId: result?.conversationId || null
+        })
+      })
+    })
+  ]),
+  completeConversation: Object.freeze([
+    Object.freeze({
+      type: "entity.changed",
+      source: "assistant",
+      entity: "conversation",
+      operation: "updated",
+      entityId: ({ result }) => result?.id,
+      realtime: Object.freeze({
+        event: ASSISTANT_TRANSCRIPT_CHANGED_EVENT,
+        audience: "event_scope",
+        payload: ({ result }) => ({
+          conversationId: result?.id || null
+        })
+      })
+    })
+  ])
+});
+
+function resolveWorkspaceId(workspace) {
+  const workspaceId = parsePositiveInteger(workspace?.id || workspace);
+  if (!workspaceId) {
+    throw new AppError(409, "Workspace selection required.");
+  }
+
+  return workspaceId;
+}
+
+function resolveActorUserId(user, { required = false } = {}) {
+  const actorUserId = parsePositiveInteger(user?.id);
+  if (!actorUserId && required) {
+    throw new AppError(401, "Authentication required.");
+  }
+
+  return actorUserId;
+}
+
+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 normalizeConversationStatus(value, fallback = "active") {
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized === "active" || normalized === "completed" || normalized === "failed" || normalized === "aborted") {
+    return normalized;
+  }
+
+  return fallback;
+}
+
+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 createTranscriptService({ conversationsRepository, messagesRepository } = {}) {
+  if (!conversationsRepository || !messagesRepository) {
+    throw new Error("createTranscriptService requires conversationsRepository and messagesRepository.");
+  }
+
+  async function createConversationForTurn(workspace, user, options = {}) {
+    const workspaceId = resolveWorkspaceId(workspace);
+    const actorUserId = resolveActorUserId(user, {
+      required: true
+    });
+    const source = normalizeObject(options);
+    const conversationId = parsePositiveInteger(source.conversationId);
+
+    if (conversationId) {
+      const existing = await conversationsRepository.findByIdForWorkspaceAndUser(conversationId, workspaceId, actorUserId);
+      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: normalizeText(source.surfaceId).toLowerCase() || "admin",
+      metadata: {
+        firstMessageId: normalizeText(source.messageId)
+      }
+    });
+
+    return {
+      conversation: createdConversation,
+      created: true
+    };
+  }
+
+  async function appendMessage(conversationId, payload = {}, options = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      throw new TypeError("appendMessage requires conversationId.");
+    }
+
+    const source = normalizeObject(payload);
+    const context = normalizeObject(options.context);
+    const conversation = await conversationsRepository.findById(numericConversationId);
+    if (!conversation) {
+      throw new AppError(404, "Conversation not found.");
+    }
+
+    const actorUserId = parsePositiveInteger(source.actorUserId) || resolveActorUserId(context.actor) || null;
+    const createdMessage = await messagesRepository.create({
+      conversationId: numericConversationId,
+      workspaceId: conversation.workspaceId,
+      role: normalizeText(source.role).toLowerCase(),
+      kind: normalizeText(source.kind).toLowerCase() || "chat",
+      clientMessageId: normalizeText(source.clientMessageId),
+      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(conversationId, payload = {}) {
+    const numericConversationId = parsePositiveInteger(conversationId);
+    if (!numericConversationId) {
+      throw new TypeError("completeConversation requires conversationId.");
+    }
+
+    const source = normalizeObject(payload);
+    const existing = await conversationsRepository.findById(numericConversationId);
+    if (!existing) {
+      throw new AppError(404, "Conversation not found.");
+    }
+
+    return conversationsRepository.updateById(numericConversationId, {
+      status: normalizeConversationStatus(source.status, "completed"),
+      endedAt: source.endedAt || new Date(),
+      metadata: {
+        ...normalizeObject(existing.metadata),
+        ...normalizeObject(source.metadata)
+      }
+    });
+  }
+
+  async function listConversationsForUser(workspace, user, query = {}) {
+    const workspaceId = resolveWorkspaceId(workspace);
+    const actorUserId = resolveActorUserId(user, {
+      required: true
+    });
+    const pagination = normalizeCursorPagination(query, {
+      defaultLimit: DEFAULT_PAGE_SIZE,
+      maxLimit: MAX_PAGE_SIZE
+    });
+
+    const status = normalizeConversationStatus(query.status, "");
+    const filters = {
+      ...(status ? { status } : {})
+    };
+
+    return conversationsRepository.listForWorkspaceAndUser(
+      workspaceId,
+      actorUserId,
+      {
+        cursor: pagination.cursor,
+        limit: pagination.limit
+      },
+      filters
+    );
+  }
+
+  async function getConversationMessagesForUser(workspace, user, conversationId, query = {}) {
+    const workspaceId = resolveWorkspaceId(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.findByIdForWorkspaceAndUser(
+      numericConversationId,
+      workspaceId,
+      actorUserId
+    );
+    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.countByConversationForWorkspace(numericConversationId, workspaceId);
+    const totalPages = Math.max(1, Math.ceil(total / pagination.pageSize));
+    const page = Math.min(pagination.page, totalPages);
+    const entries = await messagesRepository.listByConversationForWorkspace(
+      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,
+  serviceEvents
+};

package/src/shared/assistantPaths.js

@@ -0,0 +1,50 @@
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizePathname } from "@jskit-ai/kernel/shared/surface/paths";
+import { normalizeScopedRouteVisibility } from "@jskit-ai/users-core/shared/support/usersVisibility";
+
+const ASSISTANT_API_RELATIVE_PATH = "/assistant";
+const ASSISTANT_WORKSPACE_API_BASE_PATH_TEMPLATE = "/api/w/:workspaceSlug/assistant";
+const ASSISTANT_PUBLIC_API_BASE_PATH = `/api${ASSISTANT_API_RELATIVE_PATH}`;
+
+function resolveAssistantApiBasePath({ visibility = "workspace" } = {}) {
+  const normalizedVisibility = normalizeScopedRouteVisibility(visibility, {
+    fallback: "workspace"
+  });
+  if (normalizedVisibility === "workspace" || normalizedVisibility === "workspace_user") {
+    return ASSISTANT_WORKSPACE_API_BASE_PATH_TEMPLATE;
+  }
+
+  return ASSISTANT_PUBLIC_API_BASE_PATH;
+}
+
+function resolveAssistantWorkspaceApiBasePath(workspaceSlug = "") {
+  const normalizedWorkspaceSlug = normalizeText(workspaceSlug).toLowerCase();
+  if (!normalizedWorkspaceSlug) {
+    return "";
+  }
+
+  return `/api/w/${encodeURIComponent(normalizedWorkspaceSlug)}${ASSISTANT_API_RELATIVE_PATH}`;
+}
+
+function buildAssistantWorkspaceApiPath(workspaceSlug = "", suffix = "/") {
+  const basePath = resolveAssistantWorkspaceApiBasePath(workspaceSlug);
+  if (!basePath) {
+    return "";
+  }
+
+  const normalizedSuffix = normalizePathname(suffix);
+  if (normalizedSuffix === "/") {
+    return basePath;
+  }
+
+  return `${basePath}${normalizedSuffix}`;
+}
+
+export {
+  ASSISTANT_API_RELATIVE_PATH,
+  ASSISTANT_WORKSPACE_API_BASE_PATH_TEMPLATE,
+  ASSISTANT_PUBLIC_API_BASE_PATH,
+  resolveAssistantApiBasePath,
+  resolveAssistantWorkspaceApiBasePath,
+  buildAssistantWorkspaceApiPath
+};

package/src/shared/assistantResource.js

@@ -0,0 +1,323 @@
+import { Type } from "typebox";
+import {
+  normalizeObjectInput,
+  createCursorListValidator
+} from "@jskit-ai/kernel/shared/validators";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
+import { toPositiveInteger } from "./support/positiveInteger.js";
+
+const MAX_INPUT_CHARS = 8000;
+const MAX_HISTORY_MESSAGES = 20;
+const MAX_PAGE_SIZE = 200;
+const MAX_MESSAGE_PAGE_SIZE = 500;
+
+function normalizePaginationValue(value, fallback, max) {
+  const parsed = toPositiveInteger(value, fallback);
+  return Math.max(1, Math.min(max, parsed));
+}
+
+function normalizeConversationStatus(value) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized === "active" || normalized === "completed" || normalized === "failed" || normalized === "aborted") {
+    return normalized;
+  }
+
+  return "";
+}
+
+function normalizeChatStreamBody(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const normalized = {
+    messageId: normalizeText(source.messageId),
+    input: normalizeText(source.input)
+  };
+
+  const conversationId = toPositiveInteger(source.conversationId, 0);
+  if (conversationId > 0) {
+    normalized.conversationId = conversationId;
+  }
+
+  const history = Array.isArray(source.history) ? source.history : [];
+  normalized.history = history
+    .slice(0, MAX_HISTORY_MESSAGES)
+    .map((entry) => {
+      const item = normalizeObjectInput(entry);
+      const role = normalizeText(item.role).toLowerCase();
+      if (role !== "user" && role !== "assistant") {
+        return null;
+      }
+
+      const content = normalizeText(item.content);
+      if (!content) {
+        return null;
+      }
+
+      return {
+        role,
+        content: content.slice(0, MAX_INPUT_CHARS)
+      };
+    })
+    .filter(Boolean);
+
+  const clientContext = normalizeObjectInput(source.clientContext);
+  if (Object.keys(clientContext).length > 0) {
+    normalized.clientContext = {
+      locale: normalizeText(clientContext.locale),
+      timezone: normalizeText(clientContext.timezone)
+    };
+  }
+
+  return normalized;
+}
+
+function normalizeConversationsListQuery(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  const status = normalizeConversationStatus(source.status);
+  const normalized = {};
+
+  if (Object.hasOwn(source, "cursor")) {
+    normalized.cursor = toPositiveInteger(source.cursor, 0);
+  }
+  if (Object.hasOwn(source, "limit")) {
+    normalized.limit = toPositiveInteger(source.limit, 0);
+  }
+  if (status) {
+    normalized.status = status;
+  }
+
+  return normalized;
+}
+
+function normalizeConversationMessagesQuery(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    page: normalizePaginationValue(source.page, 1, MAX_MESSAGE_PAGE_SIZE),
+    pageSize: normalizePaginationValue(source.pageSize, 200, MAX_MESSAGE_PAGE_SIZE)
+  };
+}
+
+function normalizeConversationMessagesParams(payload = {}) {
+  const source = normalizeObjectInput(payload);
+  return {
+    conversationId: toPositiveInteger(source.conversationId, 0)
+  };
+}
+
+function createOptionalPositiveIntegerQuerySchema(max = null) {
+  const numericSchema = max == null
+    ? Type.Integer({ minimum: 1 })
+    : Type.Integer({ minimum: 1, maximum: max });
+
+  return Type.Optional(
+    Type.Union([
+      numericSchema,
+      Type.String({ pattern: "^[1-9][0-9]*$" })
+    ])
+  );
+}
+
+function normalizeConversationRecord(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    id: toPositiveInteger(source.id, 0),
+    workspaceId: toPositiveInteger(source.workspaceId, 0),
+    workspaceSlug: normalizeText(source.workspaceSlug),
+    workspaceName: normalizeText(source.workspaceName),
+    title: normalizeText(source.title),
+    createdByUserId: toPositiveInteger(source.createdByUserId, 0) || null,
+    createdByUserDisplayName: normalizeText(source.createdByUserDisplayName),
+    createdByUserEmail: normalizeText(source.createdByUserEmail),
+    status: normalizeText(source.status),
+    provider: normalizeText(source.provider),
+    model: normalizeText(source.model),
+    surfaceId: normalizeText(source.surfaceId),
+    startedAt: normalizeText(source.startedAt),
+    endedAt: normalizeText(source.endedAt) || null,
+    messageCount: Math.max(0, Number(source.messageCount || 0)),
+    metadata: normalizeObjectInput(source.metadata),
+    createdAt: normalizeText(source.createdAt),
+    updatedAt: normalizeText(source.updatedAt)
+  };
+}
+
+function normalizeConversationMessageRecord(payload = {}) {
+  const source = normalizeObjectInput(payload);
+
+  return {
+    id: toPositiveInteger(source.id, 0),
+    conversationId: toPositiveInteger(source.conversationId, 0),
+    workspaceId: toPositiveInteger(source.workspaceId, 0),
+    seq: toPositiveInteger(source.seq, 0),
+    role: normalizeText(source.role),
+    kind: normalizeText(source.kind),
+    clientMessageId: normalizeText(source.clientMessageId),
+    actorUserId: toPositiveInteger(source.actorUserId, 0) || null,
+    contentText: source.contentText == null ? null : String(source.contentText),
+    metadata: normalizeObjectInput(source.metadata),
+    createdAt: normalizeText(source.createdAt)
+  };
+}
+
+const historyMessageSchema = Type.Object(
+  {
+    role: Type.Union([Type.Literal("user"), Type.Literal("assistant")]),
+    content: Type.String({ minLength: 1, maxLength: MAX_INPUT_CHARS })
+  },
+  { additionalProperties: false }
+);
+
+const chatStreamBodySchema = Type.Object(
+  {
+    messageId: Type.String({ minLength: 1, maxLength: 128 }),
+    conversationId: Type.Optional(Type.Integer({ minimum: 1 })),
+    input: Type.String({ minLength: 1, maxLength: MAX_INPUT_CHARS }),
+    history: Type.Optional(Type.Array(historyMessageSchema, { maxItems: MAX_HISTORY_MESSAGES })),
+    clientContext: Type.Optional(
+      Type.Object(
+        {
+          locale: Type.Optional(Type.String({ maxLength: 64 })),
+          timezone: Type.Optional(Type.String({ maxLength: 64 }))
+        },
+        { additionalProperties: false }
+      )
+    )
+  },
+  {
+    additionalProperties: false
+  }
+);
+
+const conversationRecordSchema = Type.Object(
+  {
+    id: Type.Integer({ minimum: 1 }),
+    workspaceId: Type.Integer({ minimum: 1 }),
+    workspaceSlug: Type.String(),
+    workspaceName: Type.String(),
+    title: Type.String(),
+    createdByUserId: Type.Union([Type.Integer({ minimum: 1 }), Type.Null()]),
+    createdByUserDisplayName: Type.String(),
+    createdByUserEmail: Type.String(),
+    status: Type.String(),
+    provider: Type.String(),
+    model: Type.String(),
+    surfaceId: Type.String(),
+    startedAt: Type.String({ minLength: 1 }),
+    endedAt: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
+    messageCount: Type.Integer({ minimum: 0 }),
+    metadata: Type.Record(Type.String(), Type.Unknown()),
+    createdAt: Type.String({ minLength: 1 }),
+    updatedAt: Type.String({ minLength: 1 })
+  },
+  { additionalProperties: false }
+);
+
+const conversationRecordValidator = Object.freeze({
+  schema: conversationRecordSchema,
+  normalize: normalizeConversationRecord
+});
+
+const messageRecordSchema = Type.Object(
+  {
+    id: Type.Integer({ minimum: 1 }),
+    conversationId: Type.Integer({ minimum: 1 }),
+    workspaceId: Type.Integer({ minimum: 1 }),
+    seq: Type.Integer({ minimum: 1 }),
+    role: Type.String({ minLength: 1 }),
+    kind: Type.String({ minLength: 1 }),
+    clientMessageId: Type.String(),
+    actorUserId: Type.Union([Type.Integer({ minimum: 1 }), Type.Null()]),
+    contentText: Type.Union([Type.String(), Type.Null()]),
+    metadata: Type.Record(Type.String(), Type.Unknown()),
+    createdAt: Type.String({ minLength: 1 })
+  },
+  { additionalProperties: false }
+);
+
+const paginationProperties = Object.freeze({
+  page: Type.Integer({ minimum: 1 }),
+  pageSize: Type.Integer({ minimum: 1 }),
+  total: Type.Integer({ minimum: 0 }),
+  totalPages: Type.Integer({ minimum: 1 })
+});
+
+const assistantResource = Object.freeze({
+  resource: "assistant",
+  operations: {
+    chatStream: {
+      method: "POST",
+      bodyValidator: Object.freeze({
+        schema: chatStreamBodySchema,
+        normalize: normalizeChatStreamBody
+      })
+    },
+    conversationsList: {
+      method: "GET",
+      queryValidator: Object.freeze({
+        schema: Type.Object(
+          {
+            cursor: createOptionalPositiveIntegerQuerySchema(),
+            limit: createOptionalPositiveIntegerQuerySchema(MAX_PAGE_SIZE),
+            status: Type.Optional(Type.String({ minLength: 1, maxLength: 32 }))
+          },
+          { additionalProperties: false }
+        ),
+        normalize: normalizeConversationsListQuery
+      }),
+      outputValidator: createCursorListValidator(conversationRecordValidator)
+    },
+    conversationMessagesList: {
+      method: "GET",
+      paramsValidator: Object.freeze({
+        schema: Type.Object(
+          {
+            conversationId: Type.Union([
+              Type.Integer({ minimum: 1 }),
+              Type.String({ pattern: "^[1-9][0-9]*$" })
+            ])
+          },
+          { additionalProperties: false }
+        ),
+        normalize: normalizeConversationMessagesParams
+      }),
+      queryValidator: Object.freeze({
+        schema: Type.Object(
+          {
+            page: createOptionalPositiveIntegerQuerySchema(),
+            pageSize: createOptionalPositiveIntegerQuerySchema(MAX_MESSAGE_PAGE_SIZE)
+          },
+          { additionalProperties: false }
+        ),
+        normalize: normalizeConversationMessagesQuery
+      }),
+      outputValidator: Object.freeze({
+        schema: Type.Object(
+          {
+            ...paginationProperties,
+            conversation: conversationRecordSchema,
+            entries: Type.Array(messageRecordSchema)
+          },
+          { additionalProperties: false }
+        ),
+        normalize(payload = {}) {
+          const source = normalizeObjectInput(payload);
+          return {
+            conversation: normalizeConversationRecord(source.conversation),
+            entries: (Array.isArray(source.entries) ? source.entries : []).map(normalizeConversationMessageRecord),
+            page: normalizePaginationValue(source.page, 1, MAX_MESSAGE_PAGE_SIZE),
+            pageSize: normalizePaginationValue(source.pageSize, 200, MAX_MESSAGE_PAGE_SIZE),
+            total: Math.max(0, Number(source.total || 0)),
+            totalPages: Math.max(1, Number(source.totalPages || 1))
+          };
+        }
+      })
+    }
+  }
+});
+
+export {
+  MAX_INPUT_CHARS,
+  MAX_HISTORY_MESSAGES,
+  assistantResource
+};