@purpleschool/gptbot-tools 0.2.7-stage → 0.2.8-stage

package/build/html-page-builder/commands/create-html-page-builder-session.command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateHtmlPageBuilderSessionCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var CreateHtmlPageBuilderSessionCommand;
+(function (CreateHtmlPageBuilderSessionCommand) {
+    CreateHtmlPageBuilderSessionCommand.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        title: zod_1.z.string().optional(),
+    })
+        .refine((data) => {
+        return !(data.userId && data.unregisteredUserId);
+    }, {
+        message: 'userId and unregisteredUserId cannot be used together',
+        path: ['userId', 'unregisteredUserId'],
+    })
+        .refine((data) => { var _a; return Boolean((_a = data.userId) !== null && _a !== void 0 ? _a : data.unregisteredUserId); }, {
+        message: 'userId or unregisteredUserId is required',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    CreateHtmlPageBuilderSessionCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.HtmlPageBuilderSessionSchema);
+})(CreateHtmlPageBuilderSessionCommand || (exports.CreateHtmlPageBuilderSessionCommand = CreateHtmlPageBuilderSessionCommand = {}));

package/build/html-page-builder/commands/get-html-page-builder-price.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetHtmlPageBuilderPriceCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var GetHtmlPageBuilderPriceCommand;
+(function (GetHtmlPageBuilderPriceCommand) {
+    GetHtmlPageBuilderPriceCommand.RequestSchema = zod_1.z.object({
+        modelId: zod_1.z.string().uuid(),
+    });
+    GetHtmlPageBuilderPriceCommand.ResponseDataSchema = zod_1.z.object({
+        price: zod_1.z.number(),
+    });
+    GetHtmlPageBuilderPriceCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(GetHtmlPageBuilderPriceCommand.ResponseDataSchema);
+})(GetHtmlPageBuilderPriceCommand || (exports.GetHtmlPageBuilderPriceCommand = GetHtmlPageBuilderPriceCommand = {}));

package/build/html-page-builder/commands/html-page-builder-execute.command.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlPageBuilderExecuteCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var HtmlPageBuilderExecuteCommand;
+(function (HtmlPageBuilderExecuteCommand) {
+    HtmlPageBuilderExecuteCommand.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        sessionId: zod_1.z.string().uuid().optional(),
+        userPrompt: zod_1.z.string(),
+        modelId: zod_1.z.string().uuid(),
+        params: models_1.HtmlPageBuilderJobParamsSchema,
+        tokenReservationId: zod_1.z.string().uuid().optional(),
+        precalculatedPrice: zod_1.z.number().optional(),
+    })
+        .refine((data) => {
+        return !(data.userId && data.unregisteredUserId);
+    }, {
+        message: 'userId and unregisteredUserId cannot be used together',
+        path: ['userId', 'unregisteredUserId'],
+    })
+        .refine((data) => { var _a; return Boolean((_a = data.userId) !== null && _a !== void 0 ? _a : data.unregisteredUserId); }, {
+        message: 'userId or unregisteredUserId is required',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    HtmlPageBuilderExecuteCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.HtmlPageBuilderSessionSchema);
+})(HtmlPageBuilderExecuteCommand || (exports.HtmlPageBuilderExecuteCommand = HtmlPageBuilderExecuteCommand = {}));

package/build/html-page-builder/commands/index.js

@@ -0,0 +1,22 @@
+"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 });
+__exportStar(require("./create-html-page-builder-session.command"), exports);
+__exportStar(require("./get-html-page-builder-price.command"), exports);
+__exportStar(require("./html-page-builder-execute.command"), exports);
+__exportStar(require("./soft-delete-all-html-page-builder-sessions.command"), exports);
+__exportStar(require("./soft-delete-html-page-builder-session-by-uuid.command"), exports);
+__exportStar(require("./update-html-page-builder-session-title.command"), exports);

package/build/html-page-builder/commands/soft-delete-all-html-page-builder-sessions.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftDeleteAllHtmlPageBuilderSessionsCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var SoftDeleteAllHtmlPageBuilderSessionsCommand;
+(function (SoftDeleteAllHtmlPageBuilderSessionsCommand) {
+    SoftDeleteAllHtmlPageBuilderSessionsCommand.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((data) => {
+        return !(data.userId && data.unregisteredUserId);
+    }, {
+        message: 'userId and unregisteredUserId cannot be used together',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    SoftDeleteAllHtmlPageBuilderSessionsCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(SoftDeleteAllHtmlPageBuilderSessionsCommand || (exports.SoftDeleteAllHtmlPageBuilderSessionsCommand = SoftDeleteAllHtmlPageBuilderSessionsCommand = {}));

package/build/html-page-builder/commands/soft-delete-html-page-builder-session-by-uuid.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftDeleteHtmlPageBuilderSessionByUuidCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var SoftDeleteHtmlPageBuilderSessionByUuidCommand;
+(function (SoftDeleteHtmlPageBuilderSessionByUuidCommand) {
+    SoftDeleteHtmlPageBuilderSessionByUuidCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        uuid: zod_1.z.string().uuid(),
+    });
+    SoftDeleteHtmlPageBuilderSessionByUuidCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(SoftDeleteHtmlPageBuilderSessionByUuidCommand || (exports.SoftDeleteHtmlPageBuilderSessionByUuidCommand = SoftDeleteHtmlPageBuilderSessionByUuidCommand = {}));

package/build/html-page-builder/commands/update-html-page-builder-session-title.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateHtmlPageBuilderSessionTitleCommand = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const models_1 = require("../models");
+var UpdateHtmlPageBuilderSessionTitleCommand;
+(function (UpdateHtmlPageBuilderSessionTitleCommand) {
+    UpdateHtmlPageBuilderSessionTitleCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        uuid: zod_1.z.string().uuid(),
+        title: zod_1.z.string(),
+    });
+    UpdateHtmlPageBuilderSessionTitleCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.HtmlPageBuilderSessionSchema);
+})(UpdateHtmlPageBuilderSessionTitleCommand || (exports.UpdateHtmlPageBuilderSessionTitleCommand = UpdateHtmlPageBuilderSessionTitleCommand = {}));

package/build/html-page-builder/enums/html-page-builder-session-stage.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTML_PAGE_BUILDER_SESSION_STAGE = void 0;
+var HTML_PAGE_BUILDER_SESSION_STAGE;
+(function (HTML_PAGE_BUILDER_SESSION_STAGE) {
+    HTML_PAGE_BUILDER_SESSION_STAGE["BUILD"] = "BUILD";
+    HTML_PAGE_BUILDER_SESSION_STAGE["REFINE"] = "REFINE";
+})(HTML_PAGE_BUILDER_SESSION_STAGE || (exports.HTML_PAGE_BUILDER_SESSION_STAGE = HTML_PAGE_BUILDER_SESSION_STAGE = {}));

package/build/html-page-builder/enums/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./html-page-builder-session-stage.enum"), exports);

package/build/html-page-builder/index.js

@@ -0,0 +1,21 @@
+"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 });
+__exportStar(require("./commands"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./queries"), exports);
+__exportStar(require("./routes"), exports);

package/build/html-page-builder/models/html-page-builder-config.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlPageBuilderConfigSchema = void 0;
+const zod_1 = require("zod");
+const html_page_builder_model_schema_1 = require("./html-page-builder-model.schema");
+exports.HtmlPageBuilderConfigSchema = zod_1.z.object({
+    models: zod_1.z.array(html_page_builder_model_schema_1.HtmlPageBuilderModelSchema),
+});

package/build/html-page-builder/models/html-page-builder-job.schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlPageBuilderJobSchema = exports.HtmlPageBuilderJobParamsSchema = void 0;
+const zod_1 = require("zod");
+const tools_1 = require("../../tools");
+const common_1 = require("../../common");
+exports.HtmlPageBuilderJobParamsSchema = zod_1.z.object({
+    attachedFiles: zod_1.z.array(common_1.AttachedFileSchema),
+});
+exports.HtmlPageBuilderJobSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    sessionId: zod_1.z.string(),
+    modelId: zod_1.z.string(),
+    userPrompt: zod_1.z.string(),
+    title: zod_1.z.string(),
+    generatedHtml: zod_1.z.string().nullable().optional(),
+    status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    error: zod_1.z.string().nullable(),
+    internalError: zod_1.z.string().nullable().optional(),
+    price: zod_1.z.number(),
+    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
+    inputTokens: zod_1.z.number().nullable().optional(),
+    outputTokens: zod_1.z.number().nullable().optional(),
+    totalTokens: zod_1.z.number().nullable().optional(),
+    tokenReservationId: zod_1.z.string().nullable().optional(),
+    userId: zod_1.z.string().nullable().optional(),
+    unregisteredUserId: zod_1.z.string().nullable().optional(),
+    params: exports.HtmlPageBuilderJobParamsSchema,
+    isDeleted: zod_1.z.boolean(),
+    createdAt: zod_1.z.date(),
+    completedAt: zod_1.z.date().nullable().optional(),
+    updatedAt: zod_1.z.date(),
+});

package/build/html-page-builder/models/html-page-builder-model.schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlPageBuilderModelSchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+exports.HtmlPageBuilderModelSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    aiModel: zod_1.z.string(),
+    price: zod_1.z.number(),
+    order: zod_1.z.number(),
+    status: zod_1.z.nativeEnum(common_1.TOOL_MODEL_STATUS),
+    icons: common_1.IconVariantsSchema,
+    maxPromptLength: zod_1.z.number(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/html-page-builder/models/html-page-builder-session.schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlPageBuilderSessionSchema = void 0;
+const zod_1 = require("zod");
+const tools_1 = require("../../tools");
+const enums_1 = require("../enums");
+exports.HtmlPageBuilderSessionSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    title: zod_1.z.string(),
+    status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    stage: zod_1.z.nativeEnum(enums_1.HTML_PAGE_BUILDER_SESSION_STAGE),
+    currentHtml: zod_1.z.string().nullable().optional(),
+    userId: zod_1.z.string().nullable().optional(),
+    unregisteredUserId: zod_1.z.string().nullable().optional(),
+    isDeleted: zod_1.z.boolean(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/html-page-builder/models/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./html-page-builder-config.schema"), exports);
+__exportStar(require("./html-page-builder-job.schema"), exports);
+__exportStar(require("./html-page-builder-model.schema"), exports);
+__exportStar(require("./html-page-builder-session.schema"), exports);

package/build/html-page-builder/queries/find-html-page-builder-session-by-id.query.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindHtmlPageBuilderSessionByIdQuery = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const models_1 = require("../models");
+var FindHtmlPageBuilderSessionByIdQuery;
+(function (FindHtmlPageBuilderSessionByIdQuery) {
+    FindHtmlPageBuilderSessionByIdQuery.RequestSchema = zod_1.z
+        .object({
+        uuid: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+    })
+        .refine((data) => { var _a; return Boolean((_a = data.userId) !== null && _a !== void 0 ? _a : data.unregisteredUserId); }, {
+        message: 'userId or unregisteredUserId is required',
+        path: ['userId', 'unregisteredUserId'],
+    })
+        .refine((data) => !(data.userId && data.unregisteredUserId), {
+        message: 'userId and unregisteredUserId cannot be used together',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    FindHtmlPageBuilderSessionByIdQuery.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.HtmlPageBuilderSessionSchema);
+})(FindHtmlPageBuilderSessionByIdQuery || (exports.FindHtmlPageBuilderSessionByIdQuery = FindHtmlPageBuilderSessionByIdQuery = {}));

package/build/html-page-builder/queries/find-html-page-builder-sessions.query.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindHtmlPageBuilderSessionsQuery = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var FindHtmlPageBuilderSessionsQuery;
+(function (FindHtmlPageBuilderSessionsQuery) {
+    FindHtmlPageBuilderSessionsQuery.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        title: zod_1.z.string().optional(),
+        limit: zod_1.z.coerce.number().min(1).optional(),
+        offset: zod_1.z.coerce.number().min(0).default(0).optional(),
+    })
+        .refine((data) => {
+        return !(data.userId && data.unregisteredUserId);
+    }, {
+        message: 'userId and unregisteredUserId cannot be used together',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    FindHtmlPageBuilderSessionsQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.object({
+        data: zod_1.z.array(models_1.HtmlPageBuilderSessionSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+    }));
+})(FindHtmlPageBuilderSessionsQuery || (exports.FindHtmlPageBuilderSessionsQuery = FindHtmlPageBuilderSessionsQuery = {}));

package/build/html-page-builder/queries/get-html-page-builder-config.query.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetHtmlPageBuilderConfigQuery = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const models_1 = require("../models");
+var GetHtmlPageBuilderConfigQuery;
+(function (GetHtmlPageBuilderConfigQuery) {
+    GetHtmlPageBuilderConfigQuery.RequestSchema = zod_1.z.object({});
+    GetHtmlPageBuilderConfigQuery.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.HtmlPageBuilderConfigSchema);
+})(GetHtmlPageBuilderConfigQuery || (exports.GetHtmlPageBuilderConfigQuery = GetHtmlPageBuilderConfigQuery = {}));

package/build/html-page-builder/queries/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./find-html-page-builder-session-by-id.query"), exports);
+__exportStar(require("./find-html-page-builder-sessions.query"), exports);
+__exportStar(require("./get-html-page-builder-config.query"), exports);

package/build/html-page-builder/routes/html-page-builder.amqp.routes.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTML_PAGE_BUILDER_AMQP_ROUTES = void 0;
+exports.HTML_PAGE_BUILDER_AMQP_ROUTES = {
+    CONFIG: 'tools.html-page-builder.config.rpc',
+    EXECUTE: 'tools.html-page-builder.execute.rpc',
+    GET_PRICE: 'tools.html-page-builder.get-price.rpc',
+    CREATE_SESSION: 'tools.html-page-builder.sessions.create.rpc',
+    LIST_SESSIONS: 'tools.html-page-builder.sessions.list.rpc',
+    GET_SESSION: 'tools.html-page-builder.sessions.get.rpc',
+    UPDATE_SESSION_TITLE: 'tools.html-page-builder.sessions.update-title.rpc',
+    SOFT_DELETE_SESSION: 'tools.html-page-builder.sessions.soft-delete.rpc',
+    SOFT_DELETE_ALL_SESSIONS: 'tools.html-page-builder.sessions.soft-delete-all.rpc',
+};

package/build/html-page-builder/routes/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./html-page-builder.amqp.routes"), exports);

package/build/index.js

@@ -57,6 +57,7 @@ __exportStar(require("./marketplace-card"), exports);
 __exportStar(require("./analytics"), exports);
 __exportStar(require("./solving-edu-task"), exports);
 __exportStar(require("./spell-corrector"), exports);
+__exportStar(require("./html-page-builder"), exports);
 __exportStar(require("./tool-workspace"), exports);
 const common = __importStar(require("./common"));
 const paraphrase = __importStar(require("./paraphrase"));
@@ -77,6 +78,7 @@ const marketplaceCard = __importStar(require("./marketplace-card"));
 const analytics = __importStar(require("./analytics"));
 const solvingEduTask = __importStar(require("./solving-edu-task"));
 const spellCorrector = __importStar(require("./spell-corrector"));
+const htmlPageBuilder = __importStar(require("./html-page-builder"));
 const accountMerge = __importStar(require("./account-merge"));
 const toolWorkspace = __importStar(require("./tool-workspace"));
 var ToolService;
@@ -100,6 +102,7 @@ var ToolService;
     ToolService.Analytics = analytics;
     ToolService.SolvingEduTask = solvingEduTask;
     ToolService.SpellCorrector = spellCorrector;
+    ToolService.HtmlPageBuilder = htmlPageBuilder;
     ToolService.AccountMerge = accountMerge;
     ToolService.ToolWorkspace = toolWorkspace;
 })(ToolService || (exports.ToolService = ToolService = {}));

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

@@ -18,4 +18,5 @@ var TOOL_CONTENT_TYPE;
     TOOL_CONTENT_TYPE["MARKETPLACE_CARD_GENERATION"] = "MARKETPLACE_CARD";
     TOOL_CONTENT_TYPE["SOLVING_EDU_TASK"] = "SOLVING_EDU_TASK";
     TOOL_CONTENT_TYPE["SPELL_CORRECTOR"] = "SPELL_CORRECTOR";
+    TOOL_CONTENT_TYPE["HTML_PAGE_BUILDER"] = "HTML_PAGE_BUILDER";
 })(TOOL_CONTENT_TYPE || (exports.TOOL_CONTENT_TYPE = TOOL_CONTENT_TYPE = {}));

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

@@ -20,4 +20,5 @@ var TOOL_TYPE;
     TOOL_TYPE["INTERIOR_DESIGN"] = "INTERIOR_DESIGN";
     TOOL_TYPE["SPELL_CORRECTOR"] = "SPELL_CORRECTOR";
     TOOL_TYPE["SOLVING_EDU_TASK"] = "SOLVING_EDU_TASK";
+    TOOL_TYPE["HTML_PAGE_BUILDER"] = "HTML_PAGE_BUILDER";
 })(TOOL_TYPE || (exports.TOOL_TYPE = TOOL_TYPE = {}));

package/build/tools/models/global-tools-config.schema.js

@@ -17,6 +17,7 @@ const models_1 = require("../../marketplace-card/models");
 const interior_design_1 = require("../../interior-design");
 const solving_edu_task_1 = require("../../solving-edu-task");
 const spell_corrector_1 = require("../../spell-corrector");
+const models_2 = require("../../html-page-builder/models");
 exports.GlobalToolsConfigSchema = zod_1.z.object({
     [enums_1.TOOL_CONTENT_TYPE.VIDEO]: video_1.VideoConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.MUSIC]: music_1.MusicConfigSchema,
@@ -32,4 +33,5 @@ exports.GlobalToolsConfigSchema = zod_1.z.object({
     [enums_1.TOOL_CONTENT_TYPE.INTERIOR_DESIGN]: interior_design_1.InteriorDesignConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.SOLVING_EDU_TASK]: solving_edu_task_1.SolvingEduTaskConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.SPELL_CORRECTOR]: spell_corrector_1.SpellCorrectorToolConfigSchema,
+    [enums_1.TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER]: models_2.HtmlPageBuilderConfigSchema,
 });

package/build/tools/models/tools-with-configs.schema.js

@@ -18,6 +18,7 @@ const tool_schema_1 = require("./tool.schema");
 const interior_design_1 = require("../../interior-design");
 const solving_edu_task_1 = require("../../solving-edu-task");
 const spell_corrector_1 = require("../../spell-corrector");
+const models_2 = require("../../html-page-builder/models");
 // Discriminated union array: Tools with their configs
 exports.ToolWithConfigSchema = zod_1.z.discriminatedUnion('contentType', [
     tool_schema_1.ToolSchema.merge(zod_1.z.object({
@@ -76,5 +77,9 @@ exports.ToolWithConfigSchema = zod_1.z.discriminatedUnion('contentType', [
         contentType: zod_1.z.literal(enums_1.TOOL_CONTENT_TYPE.SPELL_CORRECTOR),
         config: spell_corrector_1.SpellCorrectorToolConfigSchema,
     })),
+    tool_schema_1.ToolSchema.merge(zod_1.z.object({
+        contentType: zod_1.z.literal(enums_1.TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER),
+        config: models_2.HtmlPageBuilderConfigSchema,
+    })),
 ]);
 exports.ToolsWithConfigsSchema = zod_1.z.array(exports.ToolWithConfigSchema);

package/html-page-builder/commands/create-html-page-builder-session.command.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { HtmlPageBuilderSessionSchema } from '../models';
+
+export namespace CreateHtmlPageBuilderSessionCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            title: z.string().optional(),
+        })
+        .refine(
+            (data) => {
+                return !(data.userId && data.unregisteredUserId);
+            },
+            {
+                message: 'userId and unregisteredUserId cannot be used together',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        )
+        .refine((data) => Boolean(data.userId ?? data.unregisteredUserId), {
+            message: 'userId or unregisteredUserId is required',
+            path: ['userId', 'unregisteredUserId'],
+        });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(HtmlPageBuilderSessionSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/commands/get-html-page-builder-price.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetHtmlPageBuilderPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+    export type ResponseData = z.infer<typeof ResponseDataSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/commands/html-page-builder-execute.command.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { HtmlPageBuilderJobParamsSchema, HtmlPageBuilderSessionSchema } from '../models';
+
+export namespace HtmlPageBuilderExecuteCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            sessionId: z.string().uuid().optional(),
+            userPrompt: z.string(),
+            modelId: z.string().uuid(),
+            params: HtmlPageBuilderJobParamsSchema,
+            tokenReservationId: z.string().uuid().optional(),
+            precalculatedPrice: z.number().optional(),
+        })
+        .refine(
+            (data) => {
+                return !(data.userId && data.unregisteredUserId);
+            },
+            {
+                message: 'userId and unregisteredUserId cannot be used together',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        )
+        .refine((data) => Boolean(data.userId ?? data.unregisteredUserId), {
+            message: 'userId or unregisteredUserId is required',
+            path: ['userId', 'unregisteredUserId'],
+        });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(HtmlPageBuilderSessionSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/commands/index.ts

@@ -0,0 +1,6 @@
+export * from './create-html-page-builder-session.command';
+export * from './get-html-page-builder-price.command';
+export * from './html-page-builder-execute.command';
+export * from './soft-delete-all-html-page-builder-sessions.command';
+export * from './soft-delete-html-page-builder-session-by-uuid.command';
+export * from './update-html-page-builder-session-title.command';

package/html-page-builder/commands/soft-delete-all-html-page-builder-sessions.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace SoftDeleteAllHtmlPageBuilderSessionsCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+        })
+        .refine(
+            (data) => {
+                return !(data.userId && data.unregisteredUserId);
+            },
+            {
+                message: 'userId and unregisteredUserId cannot be used together',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/commands/soft-delete-html-page-builder-session-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace SoftDeleteHtmlPageBuilderSessionByUuidCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/commands/update-html-page-builder-session-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { HtmlPageBuilderSessionSchema } from '../models';
+
+export namespace UpdateHtmlPageBuilderSessionTitleCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string().uuid(),
+        title: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(HtmlPageBuilderSessionSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/enums/html-page-builder-session-stage.enum.ts

@@ -0,0 +1,4 @@
+export enum HTML_PAGE_BUILDER_SESSION_STAGE {
+    BUILD = 'BUILD',
+    REFINE = 'REFINE',
+}

package/html-page-builder/enums/index.ts

@@ -0,0 +1 @@
+export * from './html-page-builder-session-stage.enum';

package/html-page-builder/index.ts

@@ -0,0 +1,5 @@
+export * from './commands';
+export * from './enums';
+export * from './models';
+export * from './queries';
+export * from './routes';

package/html-page-builder/models/html-page-builder-config.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { HtmlPageBuilderModelSchema } from './html-page-builder-model.schema';
+
+export const HtmlPageBuilderConfigSchema = z.object({
+    models: z.array(HtmlPageBuilderModelSchema),
+});
+
+export type HtmlPageBuilderConfig = z.infer<typeof HtmlPageBuilderConfigSchema>;

package/html-page-builder/models/html-page-builder-job.schema.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { AttachedFileSchema, USER_REACTION } from '../../common';
+
+export const HtmlPageBuilderJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedFileSchema),
+});
+
+export type HtmlPageBuilderJobParams = z.infer<typeof HtmlPageBuilderJobParamsSchema>;
+
+export const HtmlPageBuilderJobSchema = z.object({
+    uuid: z.string(),
+    sessionId: z.string(),
+    modelId: z.string(),
+    userPrompt: z.string(),
+    title: z.string(),
+    generatedHtml: z.string().nullable().optional(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    internalError: z.string().nullable().optional(),
+    price: z.number(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    inputTokens: z.number().nullable().optional(),
+    outputTokens: z.number().nullable().optional(),
+    totalTokens: z.number().nullable().optional(),
+    tokenReservationId: z.string().nullable().optional(),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    params: HtmlPageBuilderJobParamsSchema,
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    completedAt: z.date().nullable().optional(),
+    updatedAt: z.date(),
+});
+
+export type HtmlPageBuilderJob = z.infer<typeof HtmlPageBuilderJobSchema>;

package/html-page-builder/models/html-page-builder-model.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
+
+export const HtmlPageBuilderModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    price: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    icons: IconVariantsSchema,
+    maxPromptLength: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type HtmlPageBuilderModel = z.infer<typeof HtmlPageBuilderModelSchema>;

package/html-page-builder/models/html-page-builder-session.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { HTML_PAGE_BUILDER_SESSION_STAGE } from '../enums';
+
+export const HtmlPageBuilderSessionSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    stage: z.nativeEnum(HTML_PAGE_BUILDER_SESSION_STAGE),
+    currentHtml: z.string().nullable().optional(),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type HtmlPageBuilderSession = z.infer<typeof HtmlPageBuilderSessionSchema>;

package/html-page-builder/models/index.ts

@@ -0,0 +1,4 @@
+export * from './html-page-builder-config.schema';
+export * from './html-page-builder-job.schema';
+export * from './html-page-builder-model.schema';
+export * from './html-page-builder-session.schema';

package/html-page-builder/queries/find-html-page-builder-session-by-id.query.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { HtmlPageBuilderSessionSchema } from '../models';
+
+export namespace FindHtmlPageBuilderSessionByIdQuery {
+    export const RequestSchema = z
+        .object({
+            uuid: z.string().uuid(),
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+        })
+        .refine((data) => Boolean(data.userId ?? data.unregisteredUserId), {
+            message: 'userId or unregisteredUserId is required',
+            path: ['userId', 'unregisteredUserId'],
+        })
+        .refine((data) => !(data.userId && data.unregisteredUserId), {
+            message: 'userId and unregisteredUserId cannot be used together',
+            path: ['userId', 'unregisteredUserId'],
+        });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(HtmlPageBuilderSessionSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/queries/find-html-page-builder-sessions.query.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { HtmlPageBuilderSessionSchema } from '../models';
+
+export namespace FindHtmlPageBuilderSessionsQuery {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+            title: z.string().optional(),
+            limit: z.coerce.number().min(1).optional(),
+            offset: z.coerce.number().min(0).default(0).optional(),
+        })
+        .refine(
+            (data) => {
+                return !(data.userId && data.unregisteredUserId);
+            },
+            {
+                message: 'userId and unregisteredUserId cannot be used together',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(HtmlPageBuilderSessionSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/queries/get-html-page-builder-config.query.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { HtmlPageBuilderConfigSchema } from '../models';
+
+export namespace GetHtmlPageBuilderConfigQuery {
+    export const RequestSchema = z.object({});
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(HtmlPageBuilderConfigSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/html-page-builder/queries/index.ts

@@ -0,0 +1,3 @@
+export * from './find-html-page-builder-session-by-id.query';
+export * from './find-html-page-builder-sessions.query';
+export * from './get-html-page-builder-config.query';

package/html-page-builder/routes/html-page-builder.amqp.routes.ts

@@ -0,0 +1,11 @@
+export const HTML_PAGE_BUILDER_AMQP_ROUTES = {
+    CONFIG: 'tools.html-page-builder.config.rpc',
+    EXECUTE: 'tools.html-page-builder.execute.rpc',
+    GET_PRICE: 'tools.html-page-builder.get-price.rpc',
+    CREATE_SESSION: 'tools.html-page-builder.sessions.create.rpc',
+    LIST_SESSIONS: 'tools.html-page-builder.sessions.list.rpc',
+    GET_SESSION: 'tools.html-page-builder.sessions.get.rpc',
+    UPDATE_SESSION_TITLE: 'tools.html-page-builder.sessions.update-title.rpc',
+    SOFT_DELETE_SESSION: 'tools.html-page-builder.sessions.soft-delete.rpc',
+    SOFT_DELETE_ALL_SESSIONS: 'tools.html-page-builder.sessions.soft-delete-all.rpc',
+} as const;

package/html-page-builder/routes/index.ts

@@ -0,0 +1 @@
+export * from './html-page-builder.amqp.routes';

package/index.ts

@@ -18,6 +18,7 @@ export * from './marketplace-card';
 export * from './analytics';
 export * from './solving-edu-task';
 export * from './spell-corrector';
+export * from './html-page-builder';
 export * from './tool-workspace';
 
 import * as common from './common';
@@ -39,6 +40,7 @@ import * as marketplaceCard from './marketplace-card';
 import * as analytics from './analytics';
 import * as solvingEduTask from './solving-edu-task';
 import * as spellCorrector from './spell-corrector';
+import * as htmlPageBuilder from './html-page-builder';
 import * as accountMerge from './account-merge';
 import * as toolWorkspace from './tool-workspace';
 
@@ -62,6 +64,7 @@ export namespace ToolService {
     export import Analytics = analytics;
     export import SolvingEduTask = solvingEduTask;
     export import SpellCorrector = spellCorrector;
+    export import HtmlPageBuilder = htmlPageBuilder;
     export import AccountMerge = accountMerge;
     export import ToolWorkspace = toolWorkspace;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.2.7-stage",
+  "version": "0.2.8-stage",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

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

@@ -14,4 +14,5 @@ export enum TOOL_CONTENT_TYPE {
     MARKETPLACE_CARD_GENERATION = 'MARKETPLACE_CARD',
     SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
     SPELL_CORRECTOR = 'SPELL_CORRECTOR',
+    HTML_PAGE_BUILDER = 'HTML_PAGE_BUILDER',
 }

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

@@ -16,4 +16,5 @@ export enum TOOL_TYPE {
     INTERIOR_DESIGN = 'INTERIOR_DESIGN',
     SPELL_CORRECTOR = 'SPELL_CORRECTOR',
     SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
+    HTML_PAGE_BUILDER = 'HTML_PAGE_BUILDER',
 }

package/tools/models/global-tools-config.schema.ts

@@ -14,6 +14,7 @@ import { MarketplaceCardConfigSchema } from '../../marketplace-card/models';
 import { InteriorDesignConfigSchema } from '../../interior-design';
 import { SolvingEduTaskConfigSchema } from '../../solving-edu-task';
 import { SpellCorrectorToolConfigSchema } from '../../spell-corrector';
+import { HtmlPageBuilderConfigSchema } from '../../html-page-builder/models';
 
 export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.VIDEO]: VideoConfigSchema,
@@ -30,6 +31,7 @@ export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.INTERIOR_DESIGN]: InteriorDesignConfigSchema,
     [TOOL_CONTENT_TYPE.SOLVING_EDU_TASK]: SolvingEduTaskConfigSchema,
     [TOOL_CONTENT_TYPE.SPELL_CORRECTOR]: SpellCorrectorToolConfigSchema,
+    [TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER]: HtmlPageBuilderConfigSchema,
 });
 
 export type GlobalToolsConfig = z.infer<typeof GlobalToolsConfigSchema>;

package/tools/models/tools-with-configs.schema.ts

@@ -15,6 +15,7 @@ import { ToolSchema } from './tool.schema';
 import { InteriorDesignConfigSchema } from '../../interior-design';
 import { SolvingEduTaskConfigSchema } from '../../solving-edu-task';
 import { SpellCorrectorToolConfigSchema } from '../../spell-corrector';
+import { HtmlPageBuilderConfigSchema } from '../../html-page-builder/models';
 
 // Discriminated union array: Tools with their configs
 export const ToolWithConfigSchema = z.discriminatedUnion('contentType', [
@@ -102,6 +103,12 @@ export const ToolWithConfigSchema = z.discriminatedUnion('contentType', [
             config: SpellCorrectorToolConfigSchema,
         }),
     ),
+    ToolSchema.merge(
+        z.object({
+            contentType: z.literal(TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER),
+            config: HtmlPageBuilderConfigSchema,
+        }),
+    ),
 ]);
 
 export type ToolWithConfig = z.infer<typeof ToolWithConfigSchema>;