@purpleschool/multisite 0.0.34 → 0.0.41

package/build/constants/text-provider/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEXT_PROVIDER_SKIP_REASON = exports.TEXT_PROVIDER_FALLBACK_REASON = exports.TEXT_PROVIDER_FAILURE_KIND = exports.TEXT_PROVIDER_ATTEMPT_EVENT = exports.TEXT_PROVIDER_TRANSPORT = exports.TEXT_PROVIDER_MESSAGE_ROLE = exports.TEXT_PROVIDER_CODE = void 0;
+var TEXT_PROVIDER_CODE;
+(function (TEXT_PROVIDER_CODE) {
+    TEXT_PROVIDER_CODE["WELLFLOW"] = "wellflow";
+    TEXT_PROVIDER_CODE["API_ROUTE"] = "api_route";
+    TEXT_PROVIDER_CODE["DEROUTER"] = "derouter";
+})(TEXT_PROVIDER_CODE || (exports.TEXT_PROVIDER_CODE = TEXT_PROVIDER_CODE = {}));
+var TEXT_PROVIDER_MESSAGE_ROLE;
+(function (TEXT_PROVIDER_MESSAGE_ROLE) {
+    TEXT_PROVIDER_MESSAGE_ROLE["SYSTEM"] = "system";
+    TEXT_PROVIDER_MESSAGE_ROLE["USER"] = "user";
+    TEXT_PROVIDER_MESSAGE_ROLE["ASSISTANT"] = "assistant";
+})(TEXT_PROVIDER_MESSAGE_ROLE || (exports.TEXT_PROVIDER_MESSAGE_ROLE = TEXT_PROVIDER_MESSAGE_ROLE = {}));
+var TEXT_PROVIDER_TRANSPORT;
+(function (TEXT_PROVIDER_TRANSPORT) {
+    TEXT_PROVIDER_TRANSPORT["AI_PROXY"] = "ai_proxy";
+})(TEXT_PROVIDER_TRANSPORT || (exports.TEXT_PROVIDER_TRANSPORT = TEXT_PROVIDER_TRANSPORT = {}));
+var TEXT_PROVIDER_ATTEMPT_EVENT;
+(function (TEXT_PROVIDER_ATTEMPT_EVENT) {
+    TEXT_PROVIDER_ATTEMPT_EVENT["START"] = "start";
+    TEXT_PROVIDER_ATTEMPT_EVENT["FIRST_DELTA"] = "first_delta";
+    TEXT_PROVIDER_ATTEMPT_EVENT["SUCCESS"] = "success";
+    TEXT_PROVIDER_ATTEMPT_EVENT["FAILED"] = "failed";
+    TEXT_PROVIDER_ATTEMPT_EVENT["CANCELLED"] = "cancelled";
+})(TEXT_PROVIDER_ATTEMPT_EVENT || (exports.TEXT_PROVIDER_ATTEMPT_EVENT = TEXT_PROVIDER_ATTEMPT_EVENT = {}));
+var TEXT_PROVIDER_FAILURE_KIND;
+(function (TEXT_PROVIDER_FAILURE_KIND) {
+    TEXT_PROVIDER_FAILURE_KIND["TIMEOUT"] = "timeout";
+    TEXT_PROVIDER_FAILURE_KIND["REQUEST"] = "request";
+    TEXT_PROVIDER_FAILURE_KIND["PROVIDER"] = "provider";
+})(TEXT_PROVIDER_FAILURE_KIND || (exports.TEXT_PROVIDER_FAILURE_KIND = TEXT_PROVIDER_FAILURE_KIND = {}));
+var TEXT_PROVIDER_FALLBACK_REASON;
+(function (TEXT_PROVIDER_FALLBACK_REASON) {
+    TEXT_PROVIDER_FALLBACK_REASON["NO_CANDIDATES"] = "no_candidates";
+    TEXT_PROVIDER_FALLBACK_REASON["QUERY_FAILED"] = "query_failed";
+    TEXT_PROVIDER_FALLBACK_REASON["EXHAUSTED"] = "exhausted";
+    TEXT_PROVIDER_FALLBACK_REASON["BUDGET"] = "budget";
+})(TEXT_PROVIDER_FALLBACK_REASON || (exports.TEXT_PROVIDER_FALLBACK_REASON = TEXT_PROVIDER_FALLBACK_REASON = {}));
+var TEXT_PROVIDER_SKIP_REASON;
+(function (TEXT_PROVIDER_SKIP_REASON) {
+    TEXT_PROVIDER_SKIP_REASON["INVALID"] = "invalid";
+    TEXT_PROVIDER_SKIP_REASON["TRAFFIC"] = "traffic";
+    TEXT_PROVIDER_SKIP_REASON["COOLDOWN"] = "cooldown";
+})(TEXT_PROVIDER_SKIP_REASON || (exports.TEXT_PROVIDER_SKIP_REASON = TEXT_PROVIDER_SKIP_REASON = {}));

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

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

package/build/constants/tools/enums/tool-type.enum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-type.enum.d.ts","sourceRoot":"","sources":["../../../../constants/tools/enums/tool-type.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACjB,gBAAgB,qBAAqB;IACrC,YAAY,iBAAiB;IAC7B,gBAAgB,qBAAqB;IACrC,GAAG,QAAQ;IACX,GAAG,QAAQ;CACd"}
+{"version":3,"file":"tool-type.enum.d.ts","sourceRoot":"","sources":["../../../../constants/tools/enums/tool-type.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACjB,IAAI,SAAS;IACb,gBAAgB,qBAAqB;IACrC,YAAY,iBAAiB;IAC7B,gBAAgB,qBAAqB;IACrC,GAAG,QAAQ;IACX,GAAG,QAAQ;CACd"}

package/build/constants/tools/enums/tool-type.enum.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TOOL_TYPE = void 0;
 var TOOL_TYPE;
 (function (TOOL_TYPE) {
+    TOOL_TYPE["TEXT"] = "text";
     TOOL_TYPE["IMAGE_GENERATION"] = "image_generation";
     TOOL_TYPE["IMAGE_EDITOR"] = "image_editor";
     TOOL_TYPE["MARKETPLACE_CARD"] = "marketplace_card";

package/build/helpers/index.d.ts

@@ -1,4 +1,5 @@
 export * from './image-generation';
 export * from './image-editor';
 export * from './openai-image-2';
+export * from './text-chat';
 //# sourceMappingURL=index.d.ts.map

package/build/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

package/build/helpers/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./image-generation"), exports);
 __exportStar(require("./image-editor"), exports);
 __exportStar(require("./openai-image-2"), exports);
+__exportStar(require("./text-chat"), exports);

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

@@ -0,0 +1,23 @@
+import { TextChatStreamFrame } from '../../models/text-chat/stream.schema';
+/** UTF-8 NDJSON, one validated JSON frame followed by LF. Not SSE. */
+export declare function encodeTextChatStreamFrame(frame: TextChatStreamFrame): string;
+/** One parser per HTTP response. EOF without a terminal frame is never success. */
+export declare class TextChatStreamParser {
+    private readonly expected;
+    private readonly maxFrameLength;
+    private readonly decoder;
+    private pending;
+    private sequence;
+    private correlation;
+    private terminal;
+    private closed;
+    private failed;
+    constructor(expected?: {
+        chatId?: string;
+        messageId?: string;
+    }, maxFrameLength?: number);
+    push(chunk: Uint8Array): TextChatStreamFrame[];
+    finish(): void;
+    private accept;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../helpers/text-chat/index.ts"],"names":[],"mappings":"AACA,OAAO,EACH,mBAAmB,EAEtB,MAAM,sCAAsC,CAAC;AAE9C,sEAAsE;AACtE,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAE5E;AAED,mFAAmF;AACnF,qBAAa,oBAAoB;IAUzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAVnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6C;IACrE,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,WAAW,CAAoD;IACvE,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;IAEvB,YACqB,QAAQ,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO,EACtD,cAAc,SAAc,EAKhD;IAED,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,mBAAmB,EAAE,CAsB7C;IAED,MAAM,IAAI,IAAI,CAMb;IAED,OAAO,CAAC,MAAM;CA4BjB"}

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextChatStreamParser = void 0;
+exports.encodeTextChatStreamFrame = encodeTextChatStreamFrame;
+const text_chat_1 = require("../../constants/text-chat");
+const stream_schema_1 = require("../../models/text-chat/stream.schema");
+/** UTF-8 NDJSON, one validated JSON frame followed by LF. Not SSE. */
+function encodeTextChatStreamFrame(frame) {
+    return `${JSON.stringify(stream_schema_1.TextChatStreamFrameSchema.parse(frame))}\n`;
+}
+/** One parser per HTTP response. EOF without a terminal frame is never success. */
+class TextChatStreamParser {
+    constructor(expected = {}, maxFrameLength = 1024 * 1024) {
+        this.expected = expected;
+        this.maxFrameLength = maxFrameLength;
+        this.decoder = new TextDecoder('utf-8', { fatal: true });
+        this.pending = '';
+        this.sequence = -1;
+        this.terminal = false;
+        this.closed = false;
+        this.failed = false;
+        if (!Number.isSafeInteger(maxFrameLength) || maxFrameLength < 1) {
+            throw new Error('Invalid stream frame limit');
+        }
+    }
+    push(chunk) {
+        if (this.closed || this.failed)
+            throw new Error('Stream parser is closed');
+        try {
+            this.pending += this.decoder.decode(chunk, { stream: true });
+            const frames = [];
+            let newline;
+            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 = stream_schema_1.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) {
+            this.failed = true;
+            throw error;
+        }
+    }
+    finish() {
+        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');
+    }
+    accept(frame) {
+        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_1.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_1.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_1.TEXT_CHAT_STREAM_EVENT.FINISH ||
+                frame.type === text_chat_1.TEXT_CHAT_STREAM_EVENT.ERROR;
+    }
+}
+exports.TextChatStreamParser = TextChatStreamParser;

package/build/models/catalog/index.d.ts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { TOOL_TYPE } from '../../constants';
+export declare const CatalogOrderSchema: z.ZodNumber;
+export declare const CatalogGroupFieldsSchema: z.ZodObject<{
+    title: z.ZodString;
+    order: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    order?: number | undefined;
+}, {
+    title: string;
+    order?: number | undefined;
+}>;
+export declare const CatalogGroupSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    order: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    title: string;
+    order: number;
+}, {
+    uuid: string;
+    title: string;
+    order: number;
+}>;
+export declare const CatalogGroupAdminSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    order: z.ZodNumber;
+} & {
+    siteId: z.ZodString;
+    createdAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+    updatedAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    title: string;
+    order: number;
+    siteId: string;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}, {
+    uuid: string;
+    title: string;
+    order: number;
+    siteId: string;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}>;
+export declare const CatalogItemSchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    title: z.ZodString;
+    order: z.ZodNumber;
+    page: z.ZodObject<{
+        uuid: z.ZodString;
+        alias: z.ZodString;
+        title: z.ZodString;
+        toolType: z.ZodNullable<z.ZodNativeEnum<typeof TOOL_TYPE>>;
+        toolOptionId: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        uuid: string;
+        alias: string;
+        title: string;
+        toolType: TOOL_TYPE | null;
+        toolOptionId: string | null;
+    }, {
+        uuid: string;
+        alias: string;
+        title: string;
+        toolType: TOOL_TYPE | null;
+        toolOptionId: string | null;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    categoryId: string;
+    title: string;
+    order: number;
+    page: {
+        uuid: string;
+        alias: string;
+        title: string;
+        toolType: TOOL_TYPE | null;
+        toolOptionId: string | null;
+    };
+}, {
+    categoryId: string;
+    title: string;
+    order: number;
+    page: {
+        uuid: string;
+        alias: string;
+        title: string;
+        toolType: TOOL_TYPE | null;
+        toolOptionId: string | null;
+    };
+}>;
+export declare const PublicCatalogGroupSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    order: z.ZodNumber;
+} & {
+    items: z.ZodArray<z.ZodObject<{
+        categoryId: z.ZodString;
+        title: z.ZodString;
+        order: z.ZodNumber;
+        page: z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            toolType: z.ZodNullable<z.ZodNativeEnum<typeof TOOL_TYPE>>;
+            toolOptionId: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            alias: string;
+            title: string;
+            toolType: TOOL_TYPE | null;
+            toolOptionId: string | null;
+        }, {
+            uuid: string;
+            alias: string;
+            title: string;
+            toolType: TOOL_TYPE | null;
+            toolOptionId: string | null;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        categoryId: string;
+        title: string;
+        order: number;
+        page: {
+            uuid: string;
+            alias: string;
+            title: string;
+            toolType: TOOL_TYPE | null;
+            toolOptionId: string | null;
+        };
+    }, {
+        categoryId: string;
+        title: string;
+        order: number;
+        page: {
+            uuid: string;
+            alias: string;
+            title: string;
+            toolType: TOOL_TYPE | null;
+            toolOptionId: string | null;
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    title: string;
+    order: number;
+    items: {
+        categoryId: string;
+        title: string;
+        order: number;
+        page: {
+            uuid: string;
+            alias: string;
+            title: string;
+            toolType: TOOL_TYPE | null;
+            toolOptionId: string | null;
+        };
+    }[];
+}, {
+    uuid: string;
+    title: string;
+    order: number;
+    items: {
+        categoryId: string;
+        title: string;
+        order: number;
+        page: {
+            uuid: string;
+            alias: string;
+            title: string;
+            toolType: TOOL_TYPE | null;
+            toolOptionId: string | null;
+        };
+    }[];
+}>;
+export type PublicCatalogGroup = z.infer<typeof PublicCatalogGroupSchema>;
+//# sourceMappingURL=index.d.ts.map

package/build/models/catalog/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../models/catalog/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,eAAO,MAAM,kBAAkB,aAA0C,CAAC;AAC1E,eAAO,MAAM,wBAAwB;;;;;;;;;EAGnC,CAAC;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5B,CAAC;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/build/models/catalog/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicCatalogGroupSchema = exports.CatalogItemSchema = exports.CatalogGroupAdminSchema = exports.CatalogGroupSchema = exports.CatalogGroupFieldsSchema = exports.CatalogOrderSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+exports.CatalogOrderSchema = zod_1.z.number().int().min(0).max(2147483647);
+exports.CatalogGroupFieldsSchema = zod_1.z.object({
+    title: zod_1.z.string().trim().min(1).max(200),
+    order: exports.CatalogOrderSchema.optional(),
+});
+exports.CatalogGroupSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    order: exports.CatalogOrderSchema,
+});
+const TimestampSchema = zod_1.z.string().datetime().or(zod_1.z.date());
+exports.CatalogGroupAdminSchema = exports.CatalogGroupSchema.extend({
+    siteId: zod_1.z.string().uuid(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});
+exports.CatalogItemSchema = zod_1.z.object({
+    categoryId: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    order: exports.CatalogOrderSchema,
+    page: zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        alias: zod_1.z.string(),
+        title: zod_1.z.string(),
+        toolType: zod_1.z.nativeEnum(constants_1.TOOL_TYPE).nullable(),
+        toolOptionId: zod_1.z.string().nullable(),
+    }),
+});
+exports.PublicCatalogGroupSchema = exports.CatalogGroupSchema.extend({
+    items: zod_1.z.array(exports.CatalogItemSchema),
+});

package/build/models/index.d.ts

@@ -16,4 +16,6 @@ export * from './page.schema';
 export * from './page-question.schema';
 export * from './stt';
 export * from './tts';
+export * from './text-chat';
+export * from './catalog';
 //# sourceMappingURL=index.d.ts.map

package/build/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,mCAAmC,CAAC;AAClD,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,mCAAmC,CAAC;AAClD,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,OAAO,CAAC;AACtB,cAAc,OAAO,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/build/models/index.js

@@ -32,3 +32,5 @@ __exportStar(require("./page.schema"), exports);
 __exportStar(require("./page-question.schema"), exports);
 __exportStar(require("./stt"), exports);
 __exportStar(require("./tts"), exports);
+__exportStar(require("./text-chat"), exports);
+__exportStar(require("./catalog"), exports);

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

@@ -10,6 +10,7 @@ export declare const PageSchema: z.ZodObject<{
     alias: z.ZodString;
     toolType: z.ZodOptional<z.ZodNullable<z.ZodNativeEnum<typeof TOOL_TYPE>>>;
     toolOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    categoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     createdAt: z.ZodDate;
     updatedAt: z.ZodDate;
 }, "strip", z.ZodTypeAny, {
@@ -22,6 +23,7 @@ export declare const PageSchema: z.ZodObject<{
     alias: string;
     toolType?: TOOL_TYPE | null | undefined;
     toolOptionId?: string | null | undefined;
+    categoryId?: string | null | undefined;
     createdAt: Date;
     updatedAt: Date;
 }, {
@@ -34,6 +36,7 @@ export declare const PageSchema: z.ZodObject<{
     alias: string;
     toolType?: TOOL_TYPE | null | undefined;
     toolOptionId?: string | null | undefined;
+    categoryId?: string | null | undefined;
     createdAt: Date;
     updatedAt: Date;
 }>;
@@ -47,6 +50,7 @@ export declare const PageWithQuestionsSchema: z.ZodObject<{
     alias: z.ZodString;
     toolType: z.ZodOptional<z.ZodNullable<z.ZodNativeEnum<typeof TOOL_TYPE>>>;
     toolOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    categoryId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     createdAt: z.ZodDate;
     updatedAt: z.ZodDate;
 } & {
@@ -82,6 +86,7 @@ export declare const PageWithQuestionsSchema: z.ZodObject<{
     alias: string;
     toolType?: TOOL_TYPE | null | undefined;
     toolOptionId?: string | null | undefined;
+    categoryId?: string | null | undefined;
     createdAt: Date;
     updatedAt: Date;
     questions: {
@@ -102,6 +107,7 @@ export declare const PageWithQuestionsSchema: z.ZodObject<{
     alias: string;
     toolType?: TOOL_TYPE | null | undefined;
     toolOptionId?: string | null | undefined;
+    categoryId?: string | null | undefined;
     createdAt: Date;
     updatedAt: Date;
     questions: {

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

@@ -1 +1 @@
-{"version":3,"file":"page.schema.d.ts","sourceRoot":"","sources":["../../models/page.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYrB,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElC,CAAC"}
+{"version":3,"file":"page.schema.d.ts","sourceRoot":"","sources":["../../models/page.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAarB,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElC,CAAC"}

package/build/models/page.schema.js

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

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

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { TOOL_TYPE } from '../../constants/tools';
+export declare const TextChatCategoryFieldsSchema: z.ZodObject<{
+    title: z.ZodString;
+    toolType: z.ZodDefault<z.ZodEnum<[TOOL_TYPE.TEXT, TOOL_TYPE.IMAGE_GENERATION, TOOL_TYPE.IMAGE_EDITOR]>>;
+    placeholder: z.ZodDefault<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    order: z.ZodOptional<z.ZodNumber>;
+    prompt: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodString>>, string | null | undefined, string | null | undefined>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    toolType: TOOL_TYPE.TEXT | TOOL_TYPE.IMAGE_GENERATION | TOOL_TYPE.IMAGE_EDITOR;
+    placeholder: string;
+    groupId?: string | null | undefined;
+    order?: number | undefined;
+    prompt?: string | null | undefined;
+}, {
+    title: string;
+    toolType?: TOOL_TYPE.TEXT | TOOL_TYPE.IMAGE_GENERATION | TOOL_TYPE.IMAGE_EDITOR | undefined;
+    placeholder?: string | undefined;
+    groupId?: string | null | undefined;
+    order?: number | undefined;
+    prompt?: string | null | undefined;
+}>;
+/** Explicit allowlist. Never extend the administrative schema for public responses. */
+export declare const TextChatCategoryPublicSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    placeholder: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    title: string;
+    placeholder: string;
+}, {
+    uuid: string;
+    title: string;
+    placeholder: string;
+}>;
+export type TextChatCategoryPublic = z.infer<typeof TextChatCategoryPublicSchema>;
+export declare const TextChatCategoryAdminSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    placeholder: z.ZodString;
+} & {
+    siteId: z.ZodString;
+    toolType: z.ZodDefault<z.ZodEnum<[TOOL_TYPE.TEXT, TOOL_TYPE.IMAGE_GENERATION, TOOL_TYPE.IMAGE_EDITOR]>>;
+    groupId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    order: z.ZodDefault<z.ZodNumber>;
+    prompt: z.ZodNullable<z.ZodString>;
+    archivedAt: z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodDate]>>;
+    createdAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+    updatedAt: z.ZodUnion<[z.ZodString, z.ZodDate]>;
+}, "strip", z.ZodTypeAny, {
+    uuid: string;
+    title: string;
+    placeholder: string;
+    siteId: string;
+    toolType: TOOL_TYPE.TEXT | TOOL_TYPE.IMAGE_GENERATION | TOOL_TYPE.IMAGE_EDITOR;
+    groupId: string | null;
+    order: number;
+    prompt: string | null;
+    archivedAt: string | Date | null;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}, {
+    uuid: string;
+    title: string;
+    placeholder: string;
+    siteId: string;
+    toolType?: TOOL_TYPE.TEXT | TOOL_TYPE.IMAGE_GENERATION | TOOL_TYPE.IMAGE_EDITOR | undefined;
+    groupId?: string | null | undefined;
+    order?: number | undefined;
+    prompt: string | null;
+    archivedAt: string | Date | null;
+    createdAt: string | Date;
+    updatedAt: string | Date;
+}>;
+export type TextChatCategoryAdmin = z.infer<typeof TextChatCategoryAdminSchema>;
+//# sourceMappingURL=category.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"category.schema.d.ts","sourceRoot":"","sources":["../../../models/text-chat/category.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGlD,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;EAcvC,CAAC;AAEH,uFAAuF;AACvF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAIvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAGlF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextChatCategoryAdminSchema = exports.TextChatCategoryPublicSchema = exports.TextChatCategoryFieldsSchema = void 0;
+const zod_1 = require("zod");
+const tools_1 = require("../../constants/tools");
+const catalog_1 = require("../catalog");
+exports.TextChatCategoryFieldsSchema = zod_1.z.object({
+    title: zod_1.z.string().trim().min(1).max(200),
+    toolType: zod_1.z
+        .enum([tools_1.TOOL_TYPE.TEXT, tools_1.TOOL_TYPE.IMAGE_GENERATION, tools_1.TOOL_TYPE.IMAGE_EDITOR])
+        .default(tools_1.TOOL_TYPE.TEXT),
+    placeholder: zod_1.z.string().trim().max(1000).default(''),
+    groupId: zod_1.z.string().uuid().nullable().optional(),
+    order: catalog_1.CatalogOrderSchema.optional(),
+    prompt: zod_1.z
+        .string()
+        .max(100000)
+        .nullable()
+        .optional()
+        .transform((value) => (typeof value === 'string' && !value.trim() ? null : value)),
+});
+/** Explicit allowlist. Never extend the administrative schema for public responses. */
+exports.TextChatCategoryPublicSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    placeholder: zod_1.z.string(),
+});
+const TimestampSchema = zod_1.z.string().datetime().or(zod_1.z.date());
+exports.TextChatCategoryAdminSchema = exports.TextChatCategoryPublicSchema.extend({
+    siteId: zod_1.z.string().uuid(),
+    toolType: exports.TextChatCategoryFieldsSchema.shape.toolType,
+    groupId: zod_1.z.string().uuid().nullable().default(null),
+    order: catalog_1.CatalogOrderSchema.default(0),
+    prompt: zod_1.z.string().nullable(),
+    archivedAt: TimestampSchema.nullable(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema,
+});