@purpleschool/multisite 0.0.34 → 0.0.41

package/build/models/text-chat/index.d.ts

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+import { FILE_TYPE, TEXT_CHAT_ERROR_CODE, TEXT_CHAT_MESSAGE_ROLE, TEXT_CHAT_MESSAGE_STATUS, TOOL_MODEL_STATUS } from '../../constants';
+export * from './stream.schema';
+export * from './provider-config.schema';
+export * from './category.schema';
+export declare const TextChatFileSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    name: z.ZodString;
+    key: z.ZodString;
+    url: z.ZodString;
+    mimeType: z.ZodString;
+    size: z.ZodNumber;
+    createdAt: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+} & {
+    type: z.ZodEnum<[FILE_TYPE.IMAGE, FILE_TYPE.TEXT, FILE_TYPE.DOCUMENT]>;
+    contentLength: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    name: string;
+    key: string;
+    url: string;
+    mimeType: string;
+    size: number;
+    createdAt?: string | Date | undefined;
+    type: FILE_TYPE.IMAGE | FILE_TYPE.TEXT | FILE_TYPE.DOCUMENT;
+    contentLength: number | null;
+}, {
+    uuid: string;
+    name: string;
+    key: string;
+    url: string;
+    mimeType: string;
+    size: number;
+    createdAt?: string | Date | undefined;
+    type: FILE_TYPE.IMAGE | FILE_TYPE.TEXT | FILE_TYPE.DOCUMENT;
+    contentLength: number | null;
+}>;
+export type TextChatFile = z.infer<typeof TextChatFileSchema>;
+export declare const TextChatModelSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    model: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodNativeEnum<typeof TOOL_MODEL_STATUS>;
+    canUse: z.ZodBoolean;
+    unlockedBy: z.ZodNullable<z.ZodObject<{
+        uuid: z.ZodString;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        name: string;
+    }, {
+        uuid: string;
+        name: string;
+    }>>;
+    supportsImageAttachment: z.ZodBoolean;
+    maxPromptLength: z.ZodNumber;
+    maxContextCharacters: z.ZodNumber;
+    order: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    title: string;
+    model: string;
+    description: string;
+    status: TOOL_MODEL_STATUS;
+    canUse: boolean;
+    unlockedBy: {
+        uuid: string;
+        name: string;
+    } | null;
+    supportsImageAttachment: boolean;
+    maxPromptLength: number;
+    maxContextCharacters: number;
+    order: number;
+}, {
+    uuid: string;
+    title: string;
+    model: string;
+    description: string;
+    status: TOOL_MODEL_STATUS;
+    canUse: boolean;
+    unlockedBy: {
+        uuid: string;
+        name: string;
+    } | null;
+    supportsImageAttachment: boolean;
+    maxPromptLength: number;
+    maxContextCharacters: number;
+    order: number;
+}>;
+export type TextChatModel = z.infer<typeof TextChatModelSchema>;
+export declare const TextChatConfigSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        title: z.ZodString;
+        model: z.ZodString;
+        description: z.ZodString;
+        status: z.ZodNativeEnum<typeof TOOL_MODEL_STATUS>;
+        canUse: z.ZodBoolean;
+        unlockedBy: z.ZodNullable<z.ZodObject<{
+            uuid: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            name: string;
+        }, {
+            uuid: string;
+            name: string;
+        }>>;
+        supportsImageAttachment: z.ZodBoolean;
+        maxPromptLength: z.ZodNumber;
+        maxContextCharacters: z.ZodNumber;
+        order: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        title: string;
+        model: string;
+        description: string;
+        status: TOOL_MODEL_STATUS;
+        canUse: boolean;
+        unlockedBy: {
+            uuid: string;
+            name: string;
+        } | null;
+        supportsImageAttachment: boolean;
+        maxPromptLength: number;
+        maxContextCharacters: number;
+        order: number;
+    }, {
+        uuid: string;
+        title: string;
+        model: string;
+        description: string;
+        status: TOOL_MODEL_STATUS;
+        canUse: boolean;
+        unlockedBy: {
+            uuid: string;
+            name: string;
+        } | null;
+        supportsImageAttachment: boolean;
+        maxPromptLength: number;
+        maxContextCharacters: number;
+        order: number;
+    }>, "many">;
+    maxFileAttachments: z.ZodNumber;
+    maxImageUploadSize: z.ZodNumber;
+    maxDocumentUploadSize: z.ZodNumber;
+    maxTextUploadSize: z.ZodNumber;
+    isAttachmentAvailable: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    models: {
+        uuid: string;
+        title: string;
+        model: string;
+        description: string;
+        status: TOOL_MODEL_STATUS;
+        canUse: boolean;
+        unlockedBy: {
+            uuid: string;
+            name: string;
+        } | null;
+        supportsImageAttachment: boolean;
+        maxPromptLength: number;
+        maxContextCharacters: number;
+        order: number;
+    }[];
+    maxFileAttachments: number;
+    maxImageUploadSize: number;
+    maxDocumentUploadSize: number;
+    maxTextUploadSize: number;
+    isAttachmentAvailable: true;
+}, {
+    models: {
+        uuid: string;
+        title: string;
+        model: string;
+        description: string;
+        status: TOOL_MODEL_STATUS;
+        canUse: boolean;
+        unlockedBy: {
+            uuid: string;
+            name: string;
+        } | null;
+        supportsImageAttachment: boolean;
+        maxPromptLength: number;
+        maxContextCharacters: number;
+        order: number;
+    }[];
+    maxFileAttachments: number;
+    maxImageUploadSize: number;
+    maxDocumentUploadSize: number;
+    maxTextUploadSize: number;
+    isAttachmentAvailable: true;
+}>;
+export type TextChatConfig = z.infer<typeof TextChatConfigSchema>;
+export declare const TextChatSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    categoryId: z.ZodNullable<z.ZodString>;
+    lastUsedAiModelId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+    updatedAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    title: string;
+    categoryId: string | null;
+    lastUsedAiModelId?: string | null | undefined;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}, {
+    uuid: string;
+    title: string;
+    categoryId: string | null;
+    lastUsedAiModelId?: string | null | undefined;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}>;
+export type TextChat = z.infer<typeof TextChatSchema>;
+export declare const TextChatMessageSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    chatId: z.ZodString;
+    role: z.ZodNativeEnum<typeof TEXT_CHAT_MESSAGE_ROLE>;
+    status: z.ZodNativeEnum<typeof TEXT_CHAT_MESSAGE_STATUS>;
+    text: z.ZodString;
+    modelId: z.ZodNullable<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        name: z.ZodString;
+        key: z.ZodString;
+        url: z.ZodString;
+        mimeType: z.ZodString;
+        size: z.ZodNumber;
+        createdAt: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+    } & {
+        type: z.ZodEnum<[FILE_TYPE.IMAGE, FILE_TYPE.TEXT, FILE_TYPE.DOCUMENT]>;
+        contentLength: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        name: string;
+        key: string;
+        url: string;
+        mimeType: string;
+        size: number;
+        createdAt?: string | Date | undefined;
+        type: FILE_TYPE.IMAGE | FILE_TYPE.TEXT | FILE_TYPE.DOCUMENT;
+        contentLength: number | null;
+    }, {
+        uuid: string;
+        name: string;
+        key: string;
+        url: string;
+        mimeType: string;
+        size: number;
+        createdAt?: string | Date | undefined;
+        type: FILE_TYPE.IMAGE | FILE_TYPE.TEXT | FILE_TYPE.DOCUMENT;
+        contentLength: number | null;
+    }>, "many">;
+    errorCode: z.ZodNullable<z.ZodNativeEnum<typeof TEXT_CHAT_ERROR_CODE>>;
+    price: z.ZodNullable<z.ZodNumber>;
+    createdAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    chatId: string;
+    role: TEXT_CHAT_MESSAGE_ROLE;
+    status: TEXT_CHAT_MESSAGE_STATUS;
+    text: string;
+    modelId: string | null;
+    files: {
+        uuid: string;
+        name: string;
+        key: string;
+        url: string;
+        mimeType: string;
+        size: number;
+        createdAt?: string | Date | undefined;
+        type: FILE_TYPE.IMAGE | FILE_TYPE.TEXT | FILE_TYPE.DOCUMENT;
+        contentLength: number | null;
+    }[];
+    errorCode: TEXT_CHAT_ERROR_CODE | null;
+    price: number | null;
+    createdAt: string | Date;
+}, {
+    uuid: string;
+    chatId: string;
+    role: TEXT_CHAT_MESSAGE_ROLE;
+    status: TEXT_CHAT_MESSAGE_STATUS;
+    text: string;
+    modelId: string | null;
+    files: {
+        uuid: string;
+        name: string;
+        key: string;
+        url: string;
+        mimeType: string;
+        size: number;
+        createdAt?: string | Date | undefined;
+        type: FILE_TYPE.IMAGE | FILE_TYPE.TEXT | FILE_TYPE.DOCUMENT;
+        contentLength: number | null;
+    }[];
+    errorCode: TEXT_CHAT_ERROR_CODE | null;
+    price: number | null;
+    createdAt: string | Date;
+}>;
+export type TextChatMessage = z.infer<typeof TextChatMessageSchema>;
+export declare const TextChatPriceSchema: z.ZodObject<{
+    price: z.ZodNumber;
+    charsUntilNextPriceIncrease: z.ZodNullable<z.ZodNumber>;
+    charsUntilNextPriceDecrease: z.ZodNullable<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    price: number;
+    charsUntilNextPriceIncrease: number | null;
+    charsUntilNextPriceDecrease: number | null;
+}, {
+    price: number;
+    charsUntilNextPriceIncrease: number | null;
+    charsUntilNextPriceDecrease: number | null;
+}>;
+export type TextChatPrice = z.infer<typeof TextChatPriceSchema>;
+//# sourceMappingURL=index.d.ts.map

package/build/models/text-chat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../models/text-chat/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACH,SAAS,EACT,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,EACxB,iBAAiB,EACpB,MAAM,iBAAiB,CAAC;AAIzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAKlC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;EASzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAK9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/build/models/text-chat/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextChatPriceSchema = exports.TextChatMessageSchema = exports.TextChatSchema = exports.TextChatConfigSchema = exports.TextChatModelSchema = exports.TextChatFileSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const file_schema_1 = require("../file.schema");
+const unlocked_by_subscription_schema_1 = require("../unlocked-by-subscription.schema");
+__exportStar(require("./stream.schema"), exports);
+__exportStar(require("./provider-config.schema"), exports);
+__exportStar(require("./category.schema"), exports);
+const CountSchema = zod_1.z.number().int().safe().nonnegative();
+const TimestampSchema = zod_1.z.string().datetime().or(zod_1.z.date());
+exports.TextChatFileSchema = file_schema_1.FileSchema.extend({
+    type: zod_1.z.enum([constants_1.FILE_TYPE.IMAGE, constants_1.FILE_TYPE.TEXT, constants_1.FILE_TYPE.DOCUMENT]),
+    contentLength: CountSchema.nullable(),
+});
+exports.TextChatModelSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    model: zod_1.z.string(),
+    description: zod_1.z.string(),
+    status: zod_1.z.nativeEnum(constants_1.TOOL_MODEL_STATUS),
+    canUse: zod_1.z.boolean(),
+    unlockedBy: unlocked_by_subscription_schema_1.UnlockedBySchema.nullable(),
+    supportsImageAttachment: zod_1.z.boolean(),
+    maxPromptLength: CountSchema.positive(),
+    maxContextCharacters: CountSchema.positive(),
+    order: zod_1.z.number().int(),
+});
+exports.TextChatConfigSchema = zod_1.z.object({
+    models: zod_1.z.array(exports.TextChatModelSchema),
+    maxFileAttachments: CountSchema.positive(),
+    maxImageUploadSize: CountSchema.positive(),
+    maxDocumentUploadSize: CountSchema.positive(),
+    maxTextUploadSize: CountSchema.positive(),
+    isAttachmentAvailable: zod_1.z.literal(true),
+});
+exports.TextChatSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    // Independent Page.categoryId; immutable after creation.
+    categoryId: zod_1.z.string().uuid().nullable(),
+    // Optional for legacy servers; only successful assistant messages determine this value.
+    lastUsedAiModelId: zod_1.z.string().uuid().nullable().optional(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});
+exports.TextChatMessageSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    chatId: zod_1.z.string().uuid(),
+    role: zod_1.z.nativeEnum(constants_1.TEXT_CHAT_MESSAGE_ROLE),
+    status: zod_1.z.nativeEnum(constants_1.TEXT_CHAT_MESSAGE_STATUS),
+    text: zod_1.z.string(),
+    modelId: zod_1.z.string().uuid().nullable(),
+    files: zod_1.z.array(exports.TextChatFileSchema),
+    errorCode: zod_1.z.nativeEnum(constants_1.TEXT_CHAT_ERROR_CODE).nullable(),
+    price: CountSchema.nullable(),
+    createdAt: TimestampSchema,
+});
+exports.TextChatPriceSchema = zod_1.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(),
+});

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

@@ -0,0 +1,92 @@
+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 declare const TextProviderSeedSchema: z.ZodEffects<z.ZodObject<{
+    providers: z.ZodArray<z.ZodObject<{
+        code: z.ZodNativeEnum<typeof TEXT_PROVIDER_CODE>;
+        title: z.ZodString;
+        status: z.ZodNativeEnum<typeof TOOL_MODEL_STATUS>;
+    }, "strict", z.ZodTypeAny, {
+        code: TEXT_PROVIDER_CODE;
+        title: string;
+        status: TOOL_MODEL_STATUS;
+    }, {
+        code: TEXT_PROVIDER_CODE;
+        title: string;
+        status: TOOL_MODEL_STATUS;
+    }>, "many">;
+    links: z.ZodArray<z.ZodObject<{
+        modelId: z.ZodString;
+        providerCode: z.ZodNativeEnum<typeof TEXT_PROVIDER_CODE>;
+        providerModel: z.ZodString;
+        priority: z.ZodNumber;
+        trafficPercent: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        modelId: string;
+        providerCode: TEXT_PROVIDER_CODE;
+        providerModel: string;
+        priority: number;
+        trafficPercent: number;
+    }, {
+        modelId: string;
+        providerCode: TEXT_PROVIDER_CODE;
+        providerModel: string;
+        priority: number;
+        trafficPercent: number;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    providers: {
+        code: TEXT_PROVIDER_CODE;
+        title: string;
+        status: TOOL_MODEL_STATUS;
+    }[];
+    links: {
+        modelId: string;
+        providerCode: TEXT_PROVIDER_CODE;
+        providerModel: string;
+        priority: number;
+        trafficPercent: number;
+    }[];
+}, {
+    providers: {
+        code: TEXT_PROVIDER_CODE;
+        title: string;
+        status: TOOL_MODEL_STATUS;
+    }[];
+    links: {
+        modelId: string;
+        providerCode: TEXT_PROVIDER_CODE;
+        providerModel: string;
+        priority: number;
+        trafficPercent: number;
+    }[];
+}>, {
+    providers: {
+        code: TEXT_PROVIDER_CODE;
+        title: string;
+        status: TOOL_MODEL_STATUS;
+    }[];
+    links: {
+        modelId: string;
+        providerCode: TEXT_PROVIDER_CODE;
+        providerModel: string;
+        priority: number;
+        trafficPercent: number;
+    }[];
+}, {
+    providers: {
+        code: TEXT_PROVIDER_CODE;
+        title: string;
+        status: TOOL_MODEL_STATUS;
+    }[];
+    links: {
+        modelId: string;
+        providerCode: TEXT_PROVIDER_CODE;
+        providerModel: string;
+        priority: number;
+        trafficPercent: number;
+    }[];
+}>;
+export type TextProviderSeed = z.infer<typeof TextProviderSeedSchema>;
+//# sourceMappingURL=provider-config.schema.d.ts.map

package/build/models/text-chat/provider-config.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-config.schema.d.ts","sourceRoot":"","sources":["../../../models/text-chat/provider-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,mGAAmG;AACnG,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwC7B,CAAC;AACP,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/build/models/text-chat/provider-config.schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextProviderSeedSchema = void 0;
+const zod_1 = require("zod");
+const text_provider_1 = require("../../constants/text-provider");
+const tools_1 = require("../../constants/tools");
+/** Deployment configuration only. Never accepted as a chat request or exposed by public config. */
+exports.TextProviderSeedSchema = zod_1.z
+    .object({
+    providers: zod_1.z
+        .array(zod_1.z
+        .object({
+        code: zod_1.z.nativeEnum(text_provider_1.TEXT_PROVIDER_CODE),
+        title: zod_1.z.string().trim().min(1),
+        status: zod_1.z.nativeEnum(tools_1.TOOL_MODEL_STATUS),
+    })
+        .strict())
+        .max(3),
+    links: zod_1.z.array(zod_1.z
+        .object({
+        modelId: zod_1.z.string().uuid(),
+        providerCode: zod_1.z.nativeEnum(text_provider_1.TEXT_PROVIDER_CODE),
+        providerModel: zod_1.z.string().trim().min(1),
+        priority: zod_1.z.number().int().safe(),
+        trafficPercent: zod_1.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: zod_1.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: zod_1.z.ZodIssueCode.custom,
+            message: 'Duplicate model/provider link',
+        });
+    }
+});

package/build/models/text-chat/stream.schema.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { TEXT_CHAT_ERROR_CODE, TEXT_CHAT_STREAM_EVENT } from '../../constants/text-chat';
+export declare const TextChatStreamFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.START>;
+    userMessageId: z.ZodString;
+    modelId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.START;
+    userMessageId: string;
+    modelId: string;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.START;
+    userMessageId: string;
+    modelId: string;
+}>, z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.DELTA>;
+    delta: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.DELTA;
+    delta: string;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.DELTA;
+    delta: string;
+}>, z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.FINISH>;
+    price: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.FINISH;
+    price: number;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.FINISH;
+    price: number;
+}>, z.ZodObject<{
+    chatId: z.ZodString;
+    messageId: z.ZodString;
+    sequence: z.ZodNumber;
+    type: z.ZodLiteral<TEXT_CHAT_STREAM_EVENT.ERROR>;
+    code: z.ZodNativeEnum<typeof TEXT_CHAT_ERROR_CODE>;
+    message: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.ERROR;
+    code: TEXT_CHAT_ERROR_CODE;
+    message?: string | undefined;
+}, {
+    chatId: string;
+    messageId: string;
+    sequence: number;
+    type: TEXT_CHAT_STREAM_EVENT.ERROR;
+    code: TEXT_CHAT_ERROR_CODE;
+    message?: string | undefined;
+}>]>;
+export type TextChatStreamFrame = z.infer<typeof TextChatStreamFrameSchema>;
+//# sourceMappingURL=stream.schema.d.ts.map

package/build/models/text-chat/stream.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.schema.d.ts","sourceRoot":"","sources":["../../../models/text-chat/stream.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAQzF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+BpC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/build/models/text-chat/stream.schema.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextChatStreamFrameSchema = void 0;
+const zod_1 = require("zod");
+const text_chat_1 = require("../../constants/text-chat");
+const correlation = {
+    chatId: zod_1.z.string().uuid(),
+    messageId: zod_1.z.string().uuid(),
+    sequence: zod_1.z.number().int().safe().nonnegative(),
+};
+exports.TextChatStreamFrameSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.START), userMessageId: zod_1.z.string().uuid(), modelId: zod_1.z.string().uuid() }))
+        .strict(),
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.DELTA), delta: zod_1.z.string().min(1) }))
+        .strict(),
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.FINISH), price: zod_1.z.number().int().safe().positive() }))
+        .strict(),
+    zod_1.z
+        .object(Object.assign(Object.assign({}, correlation), { type: zod_1.z.literal(text_chat_1.TEXT_CHAT_STREAM_EVENT.ERROR), code: zod_1.z.nativeEnum(text_chat_1.TEXT_CHAT_ERROR_CODE), message: zod_1.z.string().min(1).optional() }))
+        .strict(),
+]);

package/build/models/user.schema.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { USER_ROLE, USER_STATUS } from '../constants';
+export declare const EmailInputSchema: z.ZodString;
 export declare const UserSchema: z.ZodObject<{
     uuid: z.ZodOptional<z.ZodString>;
     siteId: z.ZodOptional<z.ZodString>;

package/build/models/user.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.schema.d.ts","sourceRoot":"","sources":["../../models/user.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEtD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;EAOrB,CAAC"}
+{"version":3,"file":"user.schema.d.ts","sourceRoot":"","sources":["../../models/user.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEtD,eAAO,MAAM,gBAAgB,aAA0C,CAAC;AAExE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;EAOrB,CAAC"}

package/build/models/user.schema.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserSchema = void 0;
+exports.UserSchema = exports.EmailInputSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
+exports.EmailInputSchema = zod_1.z.string().trim().toLowerCase().email();
 exports.UserSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid().optional(),
     siteId: zod_1.z.string().uuid().optional(),
-    email: zod_1.z.string().email(),
+    email: exports.EmailInputSchema,
     password: zod_1.z.string().min(6).max(128),
     role: zod_1.z.nativeEnum(constants_1.USER_ROLE).optional(),
     status: zod_1.z.nativeEnum(constants_1.USER_STATUS).optional(),