@purpleschool/multisite 0.0.35 → 0.0.41

package/commands/text-chat/index.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { TextChatSchema, TextChatPriceSchema, TextChatFileSchema } from '../../models/text-chat';
+export * from './category';
+
+export namespace UploadTextChatFileCommand {
+    // Multipart field `file`. No owner, site, content or extraction metadata from the client.
+    export const ResponseSchema = z.object({ data: TextChatFileSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace CreateTextChatCommand {
+    export const RequestSchema = z
+        .object({
+            // Page.toolOptionId, supplied only when starting a specialized chat.
+            categoryId: z.string().uuid().nullable().optional(),
+        })
+        .strict();
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = z.object({ data: TextChatSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace RenameTextChatCommand {
+    export const RequestParamsSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export const RequestSchema = z.object({ title: z.string().trim().min(1).max(200) }).strict();
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = z.object({ data: TextChatSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace DeleteTextChatCommand {
+    export const RequestParamsSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export const ResponseSchema = z.object({ data: z.object({ deleted: z.literal(true) }) });
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace SendTextChatMessageCommand {
+    export const RequestParamsSchema = z.object({ uuid: z.string().uuid() });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export const RequestSchema = z
+        .object({
+            modelId: z.string().uuid(),
+            text: z.string().refine((text) => text.trim().length > 0, 'Message must not be blank'),
+            fileIds: z.array(z.string().uuid()).default([]),
+        })
+        .strict();
+    export type Request = z.infer<typeof RequestSchema>;
+    // Response is a TextChatStreamFrame sequence, not a JSON response envelope.
+}
+
+export namespace CalculateTextChatPriceCommand {
+    export const RequestSchema = z
+        .object({
+            chatId: z.string().uuid().optional(),
+            // Only new chats accept a category; existing chats use their saved category.
+            categoryId: z.string().uuid().nullable().optional(),
+            modelId: z.string().uuid(),
+            inputLength: z.number().int().safe().nonnegative(),
+            fileIds: z.array(z.string().uuid()).default([]),
+        })
+        .strict()
+        .refine(
+            (request) => !request.chatId || request.categoryId === undefined,
+            'Existing chats use their saved category',
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = z.object({ data: TextChatPriceSchema });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/catalog.ts

@@ -0,0 +1,4 @@
+export enum CATALOG_ERROR_CODE {
+    GROUP_NOT_FOUND = 'catalog_group_not_found',
+    GROUP_IN_USE = 'catalog_group_in_use',
+}

package/constants/errors/errors.ts

@@ -1,4 +1,77 @@
+import { TEXT_CHAT_ERROR_CODE } from '../text-chat';
+import { CATALOG_ERROR_CODE } from '../catalog';
+
 export const ERRORS = {
+    TEXT_CHAT_GENERATION_FAILED: {
+        message: 'Не удалось получить ответ нейросети. Попробуйте позже.',
+        code: TEXT_CHAT_ERROR_CODE.GENERATION_FAILED,
+        httpCode: 502,
+    },
+    TEXT_CHAT_STREAM_INTERRUPTED: {
+        message: 'Соединение прервано. Часть ответа могла сохраниться в истории.',
+        code: TEXT_CHAT_ERROR_CODE.STREAM_INTERRUPTED,
+        httpCode: 502,
+    },
+    TEXT_CHAT_SETTLEMENT_FAILED: {
+        message: 'Не удалось завершить обработку ответа. Проверьте сохранённую историю.',
+        code: TEXT_CHAT_ERROR_CODE.SETTLEMENT_FAILED,
+        httpCode: 500,
+    },
+    CATALOG_GROUP_NOT_FOUND: {
+        message: 'Группа каталога не найдена',
+        code: CATALOG_ERROR_CODE.GROUP_NOT_FOUND,
+        httpCode: 404,
+    },
+    CATALOG_GROUP_IN_USE: {
+        message: 'Перенесите или отвяжите категории перед удалением группы',
+        code: CATALOG_ERROR_CODE.GROUP_IN_USE,
+        httpCode: 409,
+    },
+    TEXT_CHAT_CONTEXT_LIMIT: {
+        message: 'Превышен допустимый размер запроса или контекста',
+        code: TEXT_CHAT_ERROR_CODE.CONTEXT_LIMIT,
+        httpCode: 400,
+    },
+    TEXT_CHAT_INVALID_ATTACHMENT: {
+        message: 'Недопустимое вложение текстового чата',
+        code: TEXT_CHAT_ERROR_CODE.INVALID_ATTACHMENT,
+        httpCode: 400,
+    },
+    TEXT_CHAT_NOT_FOUND: {
+        message: 'Текстовый чат не найден',
+        code: TEXT_CHAT_ERROR_CODE.NOT_FOUND,
+        httpCode: 404,
+    },
+    TEXT_CHAT_BUSY: {
+        message: 'Дождитесь завершения ответа в этом чате',
+        code: TEXT_CHAT_ERROR_CODE.BUSY,
+        httpCode: 409,
+    },
+    TEXT_CHAT_CATEGORY_TOOL_MISMATCH: {
+        message: 'Инструмент категории не соответствует инструменту страницы',
+        code: TEXT_CHAT_ERROR_CODE.CATEGORY_TOOL_MISMATCH,
+        httpCode: 409,
+    },
+    TEXT_CHAT_CATEGORY_NOT_FOUND: {
+        message: 'Категория текстового чата не найдена',
+        code: TEXT_CHAT_ERROR_CODE.CATEGORY_NOT_FOUND,
+        httpCode: 404,
+    },
+    TEXT_CHAT_CATEGORY_UNAVAILABLE: {
+        message: 'Категория недоступна для нового чата',
+        code: TEXT_CHAT_ERROR_CODE.CATEGORY_UNAVAILABLE,
+        httpCode: 409,
+    },
+    TEXT_CHAT_CATEGORY_IN_USE: {
+        message: 'Категория используется чатами или SEO-страницами; её можно архивировать',
+        code: TEXT_CHAT_ERROR_CODE.CATEGORY_IN_USE,
+        httpCode: 409,
+    },
+    TEXT_CHAT_MODEL_UNAVAILABLE: {
+        message: 'Текстовая модель недоступна',
+        code: TEXT_CHAT_ERROR_CODE.MODEL_UNAVAILABLE,
+        httpCode: 403,
+    },
     UNKNOWN_ERROR: {
         message: 'Неизвестная ошибка',
         code: 'UNKNOWN_001',

package/constants/files/enums/file-type.enum.ts

@@ -1,4 +1,6 @@
 export enum FILE_TYPE {
     IMAGE = 'image',
     AUDIO = 'audio',
+    TEXT = 'text',
+    DOCUMENT = 'document',
 }

package/constants/index.ts

@@ -14,3 +14,6 @@ export * from './image-generation';
 export * from './image-editor';
 export * from './page';
 export * from './email';
+export * from './text-chat';
+export * from './catalog';
+export * from './text-provider';

package/constants/text-chat/attachments.ts

@@ -0,0 +1,55 @@
+import { FILE_TYPE } from '../files/enums/file-type.enum';
+
+export const TEXT_CHAT_UPLOAD_LIMITS = {
+    [FILE_TYPE.IMAGE]: 5 * 1024 ** 2,
+    [FILE_TYPE.DOCUMENT]: 20 * 1024 ** 2,
+    [FILE_TYPE.TEXT]: 10 * 1024 ** 2,
+} as const;
+
+export const TEXT_CHAT_FILE_FORMATS: ReadonlyArray<{
+    extensions: readonly string[];
+    mimeType: string;
+    type: FILE_TYPE.IMAGE | FILE_TYPE.DOCUMENT | FILE_TYPE.TEXT;
+}> = [
+    { extensions: ['jpg', 'jpeg'], mimeType: 'image/jpeg', type: FILE_TYPE.IMAGE },
+    { extensions: ['png'], mimeType: 'image/png', type: FILE_TYPE.IMAGE },
+    { extensions: ['webp'], mimeType: 'image/webp', type: FILE_TYPE.IMAGE },
+    { extensions: ['pdf'], mimeType: 'application/pdf', type: FILE_TYPE.DOCUMENT },
+    {
+        extensions: ['docx'],
+        mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        type: FILE_TYPE.DOCUMENT,
+    },
+    {
+        extensions: ['xlsx'],
+        mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        type: FILE_TYPE.DOCUMENT,
+    },
+    { extensions: ['txt'], mimeType: 'text/plain', type: FILE_TYPE.TEXT },
+    { extensions: ['md', 'markdown'], mimeType: 'text/markdown', type: FILE_TYPE.TEXT },
+    { extensions: ['csv'], mimeType: 'text/csv', type: FILE_TYPE.TEXT },
+    { extensions: ['tsv'], mimeType: 'text/tab-separated-values', type: FILE_TYPE.TEXT },
+    { extensions: ['json'], mimeType: 'application/json', type: FILE_TYPE.TEXT },
+    { extensions: ['xml'], mimeType: 'application/xml', type: FILE_TYPE.TEXT },
+    { extensions: ['yaml', 'yml'], mimeType: 'application/x-yaml', type: FILE_TYPE.TEXT },
+    { extensions: ['html', 'htm'], mimeType: 'text/html', type: FILE_TYPE.TEXT },
+    { extensions: ['css'], mimeType: 'text/css', type: FILE_TYPE.TEXT },
+    { extensions: ['scss'], mimeType: 'text/x-scss', type: FILE_TYPE.TEXT },
+    { extensions: ['js', 'mjs', 'cjs'], mimeType: 'application/javascript', type: FILE_TYPE.TEXT },
+    { extensions: ['ts', 'tsx'], mimeType: 'application/typescript', type: FILE_TYPE.TEXT },
+    { extensions: ['sh'], mimeType: 'application/x-sh', type: FILE_TYPE.TEXT },
+    { extensions: ['py'], mimeType: 'text/x-python', type: FILE_TYPE.TEXT },
+    { extensions: ['c', 'h'], mimeType: 'text/x-c', type: FILE_TYPE.TEXT },
+    {
+        extensions: ['cpp', 'hpp', 'cc', 'cxx', 'hh', 'hxx'],
+        mimeType: 'text/x-c++',
+        type: FILE_TYPE.TEXT,
+    },
+    { extensions: ['java'], mimeType: 'text/x-java-source', type: FILE_TYPE.TEXT },
+    { extensions: ['php'], mimeType: 'text/x-php', type: FILE_TYPE.TEXT },
+    { extensions: ['rb'], mimeType: 'text/x-ruby', type: FILE_TYPE.TEXT },
+    { extensions: ['go'], mimeType: 'text/x-go', type: FILE_TYPE.TEXT },
+    { extensions: ['ini'], mimeType: 'text/x-ini', type: FILE_TYPE.TEXT },
+    { extensions: ['properties'], mimeType: 'text/x-properties', type: FILE_TYPE.TEXT },
+    { extensions: ['conf', 'config', 'env'], mimeType: 'text/x-config', type: FILE_TYPE.TEXT },
+];

package/constants/text-chat/index.ts

@@ -0,0 +1,43 @@
+export * from './attachments';
+
+export enum TEXT_CHAT_MESSAGE_ROLE {
+    USER = 'user',
+    ASSISTANT = 'assistant',
+}
+
+export enum TEXT_CHAT_MESSAGE_STATUS {
+    PENDING = 'pending',
+    SUCCESS = 'success',
+    FAILED = 'failed',
+}
+
+export enum TEXT_CHAT_ERROR_CODE {
+    CATEGORY_TOOL_MISMATCH = 'CATEGORY_TOOL_MISMATCH',
+    NOT_FOUND = 'text_chat_not_found',
+    MODEL_UNAVAILABLE = 'text_chat_model_unavailable',
+    INSUFFICIENT_BALANCE = 'text_chat_insufficient_balance',
+    INVALID_ATTACHMENT = 'text_chat_invalid_attachment',
+    CONTEXT_LIMIT = 'text_chat_context_limit',
+    BUSY = 'text_chat_busy',
+    GENERATION_FAILED = 'text_chat_generation_failed',
+    STREAM_INTERRUPTED = 'text_chat_stream_interrupted',
+    SETTLEMENT_FAILED = 'text_chat_settlement_failed',
+    CATEGORY_NOT_FOUND = 'text_chat_category_not_found',
+    CATEGORY_UNAVAILABLE = 'text_chat_category_unavailable',
+    CATEGORY_IN_USE = 'text_chat_category_in_use',
+}
+
+export enum TEXT_CHAT_CATEGORY_SCOPE {
+    ACTIVE = 'active',
+    ARCHIVED = 'archived',
+    ALL = 'all',
+}
+
+export enum TEXT_CHAT_STREAM_EVENT {
+    START = 'start',
+    DELTA = 'delta',
+    FINISH = 'finish',
+    ERROR = 'error',
+}
+
+export const TEXT_CHAT_STREAM_CONTENT_TYPE = 'application/x-ndjson' as const;

package/constants/text-provider/index.ts

@@ -0,0 +1,42 @@
+export enum TEXT_PROVIDER_CODE {
+    WELLFLOW = 'wellflow',
+    API_ROUTE = 'api_route',
+    DEROUTER = 'derouter',
+}
+
+export enum TEXT_PROVIDER_MESSAGE_ROLE {
+    SYSTEM = 'system',
+    USER = 'user',
+    ASSISTANT = 'assistant',
+}
+
+export enum TEXT_PROVIDER_TRANSPORT {
+    AI_PROXY = 'ai_proxy',
+}
+
+export enum TEXT_PROVIDER_ATTEMPT_EVENT {
+    START = 'start',
+    FIRST_DELTA = 'first_delta',
+    SUCCESS = 'success',
+    FAILED = 'failed',
+    CANCELLED = 'cancelled',
+}
+
+export enum TEXT_PROVIDER_FAILURE_KIND {
+    TIMEOUT = 'timeout',
+    REQUEST = 'request',
+    PROVIDER = 'provider',
+}
+
+export enum TEXT_PROVIDER_FALLBACK_REASON {
+    NO_CANDIDATES = 'no_candidates',
+    QUERY_FAILED = 'query_failed',
+    EXHAUSTED = 'exhausted',
+    BUDGET = 'budget',
+}
+
+export enum TEXT_PROVIDER_SKIP_REASON {
+    INVALID = 'invalid',
+    TRAFFIC = 'traffic',
+    COOLDOWN = 'cooldown',
+}

package/constants/tools/enums/tool-type.enum.ts

@@ -1,4 +1,5 @@
 export enum TOOL_TYPE {
+    TEXT = 'text',
     IMAGE_GENERATION = 'image_generation',
     IMAGE_EDITOR = 'image_editor',
     MARKETPLACE_CARD = 'marketplace_card',

package/helpers/index.ts

@@ -1,3 +1,4 @@
 export * from './image-generation';
 export * from './image-editor';
 export * from './openai-image-2';
+export * from './text-chat';

package/helpers/text-chat/index.ts

@@ -0,0 +1,91 @@
+import { TEXT_CHAT_STREAM_EVENT } from '../../constants/text-chat';
+import {
+    TextChatStreamFrame,
+    TextChatStreamFrameSchema,
+} from '../../models/text-chat/stream.schema';
+
+/** UTF-8 NDJSON, one validated JSON frame followed by LF. Not SSE. */
+export function encodeTextChatStreamFrame(frame: TextChatStreamFrame): string {
+    return `${JSON.stringify(TextChatStreamFrameSchema.parse(frame))}\n`;
+}
+
+/** One parser per HTTP response. EOF without a terminal frame is never success. */
+export class TextChatStreamParser {
+    private readonly decoder = new TextDecoder('utf-8', { fatal: true });
+    private pending = '';
+    private sequence = -1;
+    private correlation: { chatId: string; messageId: string } | undefined;
+    private terminal = false;
+    private closed = false;
+    private failed = false;
+
+    constructor(
+        private readonly expected: { chatId?: string; messageId?: string } = {},
+        private readonly maxFrameLength = 1024 * 1024,
+    ) {
+        if (!Number.isSafeInteger(maxFrameLength) || maxFrameLength < 1) {
+            throw new Error('Invalid stream frame limit');
+        }
+    }
+
+    push(chunk: Uint8Array): TextChatStreamFrame[] {
+        if (this.closed || this.failed) throw new Error('Stream parser is closed');
+        try {
+            this.pending += this.decoder.decode(chunk, { stream: true });
+            const frames: TextChatStreamFrame[] = [];
+            let newline: number;
+            while ((newline = this.pending.indexOf('\n')) !== -1) {
+                if (newline > this.maxFrameLength) throw new Error('Stream frame is too large');
+                const line = this.pending.slice(0, newline);
+                this.pending = this.pending.slice(newline + 1);
+                if (!line.trim()) continue;
+                const frame = TextChatStreamFrameSchema.parse(JSON.parse(line));
+                this.accept(frame);
+                frames.push(frame);
+            }
+            if (this.pending.length > this.maxFrameLength)
+                throw new Error('Stream frame is too large');
+            return frames;
+        } catch (error: unknown) {
+            this.failed = true;
+            throw error;
+        }
+    }
+
+    finish(): void {
+        if (this.closed || this.failed) throw new Error('Stream parser is closed');
+        this.closed = true;
+        this.pending += this.decoder.decode();
+        if (this.pending.length) throw new Error('Incomplete stream frame');
+        if (!this.terminal) throw new Error('Stream ended without a terminal frame');
+    }
+
+    private accept(frame: TextChatStreamFrame): void {
+        if (this.terminal) throw new Error('Frame received after stream completion');
+        if (frame.sequence !== this.sequence + 1) throw new Error('Invalid stream sequence');
+        if (!this.correlation) {
+            if (frame.type !== TEXT_CHAT_STREAM_EVENT.START)
+                throw new Error('Missing stream start');
+            if (
+                (this.expected.chatId && frame.chatId !== this.expected.chatId) ||
+                (this.expected.messageId && frame.messageId !== this.expected.messageId)
+            ) {
+                throw new Error('Unexpected stream correlation');
+            }
+            this.correlation = { chatId: frame.chatId, messageId: frame.messageId };
+        } else {
+            if (frame.type === TEXT_CHAT_STREAM_EVENT.START)
+                throw new Error('Duplicate stream start');
+            if (
+                frame.chatId !== this.correlation.chatId ||
+                frame.messageId !== this.correlation.messageId
+            ) {
+                throw new Error('Stream correlation changed');
+            }
+        }
+        this.sequence = frame.sequence;
+        this.terminal =
+            frame.type === TEXT_CHAT_STREAM_EVENT.FINISH ||
+            frame.type === TEXT_CHAT_STREAM_EVENT.ERROR;
+    }
+}

package/models/catalog/index.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { TOOL_TYPE } from '../../constants';
+
+export const CatalogOrderSchema = z.number().int().min(0).max(2147483647);
+export const CatalogGroupFieldsSchema = z.object({
+    title: z.string().trim().min(1).max(200),
+    order: CatalogOrderSchema.optional(),
+});
+export const CatalogGroupSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    order: CatalogOrderSchema,
+});
+const TimestampSchema = z.string().datetime().or(z.date());
+export const CatalogGroupAdminSchema = CatalogGroupSchema.extend({
+    siteId: z.string().uuid(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});
+export const CatalogItemSchema = z.object({
+    categoryId: z.string().uuid(),
+    title: z.string(),
+    order: CatalogOrderSchema,
+    page: z.object({
+        uuid: z.string().uuid(),
+        alias: z.string(),
+        title: z.string(),
+        toolType: z.nativeEnum(TOOL_TYPE).nullable(),
+        toolOptionId: z.string().nullable(),
+    }),
+});
+export const PublicCatalogGroupSchema = CatalogGroupSchema.extend({
+    items: z.array(CatalogItemSchema),
+});
+export type PublicCatalogGroup = z.infer<typeof PublicCatalogGroupSchema>;

package/models/index.ts

@@ -16,3 +16,5 @@ export * from './page.schema';
 export * from './page-question.schema';
 export * from './stt';
 export * from './tts';
+export * from './text-chat';
+export * from './catalog';

package/models/page.schema.ts

@@ -12,6 +12,7 @@ export const PageSchema = z.object({
     alias: z.string().min(3).max(16384),
     toolType: z.nativeEnum(TOOL_TYPE).nullable().optional(),
     toolOptionId: z.string().uuid().nullable().optional(),
+    categoryId: z.string().uuid().nullable().optional(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/models/text-chat/category.schema.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { TOOL_TYPE } from '../../constants/tools';
+import { CatalogOrderSchema } from '../catalog';
+
+export const TextChatCategoryFieldsSchema = z.object({
+    title: z.string().trim().min(1).max(200),
+    toolType: z
+        .enum([TOOL_TYPE.TEXT, TOOL_TYPE.IMAGE_GENERATION, TOOL_TYPE.IMAGE_EDITOR])
+        .default(TOOL_TYPE.TEXT),
+    placeholder: z.string().trim().max(1000).default(''),
+    groupId: z.string().uuid().nullable().optional(),
+    order: CatalogOrderSchema.optional(),
+    prompt: z
+        .string()
+        .max(100_000)
+        .nullable()
+        .optional()
+        .transform((value) => (typeof value === 'string' && !value.trim() ? null : value)),
+});
+
+/** Explicit allowlist. Never extend the administrative schema for public responses. */
+export const TextChatCategoryPublicSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    placeholder: z.string(),
+});
+export type TextChatCategoryPublic = z.infer<typeof TextChatCategoryPublicSchema>;
+
+const TimestampSchema = z.string().datetime().or(z.date());
+export const TextChatCategoryAdminSchema = TextChatCategoryPublicSchema.extend({
+    siteId: z.string().uuid(),
+    toolType: TextChatCategoryFieldsSchema.shape.toolType,
+    groupId: z.string().uuid().nullable().default(null),
+    order: CatalogOrderSchema.default(0),
+    prompt: z.string().nullable(),
+    archivedAt: TimestampSchema.nullable(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});
+export type TextChatCategoryAdmin = z.infer<typeof TextChatCategoryAdminSchema>;

package/models/text-chat/index.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import {
+    FILE_TYPE,
+    TEXT_CHAT_ERROR_CODE,
+    TEXT_CHAT_MESSAGE_ROLE,
+    TEXT_CHAT_MESSAGE_STATUS,
+    TOOL_MODEL_STATUS,
+} from '../../constants';
+import { FileSchema } from '../file.schema';
+import { UnlockedBySchema } from '../unlocked-by-subscription.schema';
+
+export * from './stream.schema';
+export * from './provider-config.schema';
+export * from './category.schema';
+
+const CountSchema = z.number().int().safe().nonnegative();
+const TimestampSchema = z.string().datetime().or(z.date());
+
+export const TextChatFileSchema = FileSchema.extend({
+    type: z.enum([FILE_TYPE.IMAGE, FILE_TYPE.TEXT, FILE_TYPE.DOCUMENT]),
+    contentLength: CountSchema.nullable(),
+});
+export type TextChatFile = z.infer<typeof TextChatFileSchema>;
+
+export const TextChatModelSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    model: z.string(),
+    description: z.string(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    canUse: z.boolean(),
+    unlockedBy: UnlockedBySchema.nullable(),
+    supportsImageAttachment: z.boolean(),
+    maxPromptLength: CountSchema.positive(),
+    maxContextCharacters: CountSchema.positive(),
+    order: z.number().int(),
+});
+export type TextChatModel = z.infer<typeof TextChatModelSchema>;
+
+export const TextChatConfigSchema = z.object({
+    models: z.array(TextChatModelSchema),
+    maxFileAttachments: CountSchema.positive(),
+    maxImageUploadSize: CountSchema.positive(),
+    maxDocumentUploadSize: CountSchema.positive(),
+    maxTextUploadSize: CountSchema.positive(),
+    isAttachmentAvailable: z.literal(true),
+});
+export type TextChatConfig = z.infer<typeof TextChatConfigSchema>;
+
+export const TextChatSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    // Independent Page.categoryId; immutable after creation.
+    categoryId: z.string().uuid().nullable(),
+    // Optional for legacy servers; only successful assistant messages determine this value.
+    lastUsedAiModelId: z.string().uuid().nullable().optional(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});
+export type TextChat = z.infer<typeof TextChatSchema>;
+
+export const TextChatMessageSchema = z.object({
+    uuid: z.string().uuid(),
+    chatId: z.string().uuid(),
+    role: z.nativeEnum(TEXT_CHAT_MESSAGE_ROLE),
+    status: z.nativeEnum(TEXT_CHAT_MESSAGE_STATUS),
+    text: z.string(),
+    modelId: z.string().uuid().nullable(),
+    files: z.array(TextChatFileSchema),
+    errorCode: z.nativeEnum(TEXT_CHAT_ERROR_CODE).nullable(),
+    price: CountSchema.nullable(),
+    createdAt: TimestampSchema,
+});
+export type TextChatMessage = z.infer<typeof TextChatMessageSchema>;
+
+export const TextChatPriceSchema = z.object({
+    price: CountSchema.positive(),
+    // Distances from the requested draft inputLength; null means no boundary in that direction.
+    charsUntilNextPriceIncrease: CountSchema.positive().nullable(),
+    charsUntilNextPriceDecrease: CountSchema.positive().nullable(),
+});
+export type TextChatPrice = z.infer<typeof TextChatPriceSchema>;

package/models/text-chat/provider-config.schema.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { TEXT_PROVIDER_CODE } from '../../constants/text-provider';
+import { TOOL_MODEL_STATUS } from '../../constants/tools';
+
+/** Deployment configuration only. Never accepted as a chat request or exposed by public config. */
+export const TextProviderSeedSchema = z
+    .object({
+        providers: z
+            .array(
+                z
+                    .object({
+                        code: z.nativeEnum(TEXT_PROVIDER_CODE),
+                        title: z.string().trim().min(1),
+                        status: z.nativeEnum(TOOL_MODEL_STATUS),
+                    })
+                    .strict(),
+            )
+            .max(3),
+        links: z.array(
+            z
+                .object({
+                    modelId: z.string().uuid(),
+                    providerCode: z.nativeEnum(TEXT_PROVIDER_CODE),
+                    providerModel: z.string().trim().min(1),
+                    priority: z.number().int().safe(),
+                    trafficPercent: z.number().int().min(0).max(100),
+                })
+                .strict(),
+        ),
+    })
+    .strict()
+    .superRefine((config, context) => {
+        if (
+            new Set(config.providers.map((provider) => provider.code)).size !==
+            config.providers.length
+        ) {
+            context.addIssue({ code: z.ZodIssueCode.custom, message: 'Duplicate provider' });
+        }
+        const pairs = config.links.map((link) => `${link.modelId}:${link.providerCode}`);
+        if (new Set(pairs).size !== pairs.length) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Duplicate model/provider link',
+            });
+        }
+    });
+export type TextProviderSeed = z.infer<typeof TextProviderSeedSchema>;