@purpleschool/gptbot-tools 0.2.43 → 0.2.45

package/build/image-recognition/commands/delete-all-image-recognition-jobs.command.js

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

package/build/image-recognition/commands/delete-image-recognition-job-by-uuid.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteImageRecognitionJobByUuidCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var DeleteImageRecognitionJobByUuidCommand;
+(function (DeleteImageRecognitionJobByUuidCommand) {
+    DeleteImageRecognitionJobByUuidCommand.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(),
+    });
+    DeleteImageRecognitionJobByUuidCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(DeleteImageRecognitionJobByUuidCommand || (exports.DeleteImageRecognitionJobByUuidCommand = DeleteImageRecognitionJobByUuidCommand = {}));

package/build/image-recognition/commands/get-image-recognition-price.command.js

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

package/build/image-recognition/commands/image-recognition.command.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageRecognitionCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+const common_1 = require("../../common");
+var ImageRecognitionCommand;
+(function (ImageRecognitionCommand) {
+    ImageRecognitionCommand.RequestSchema = zod_1.z.object({
+        locale: common_1.LocaleSchema,
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        prompt: zod_1.z.string().optional(),
+        categoryId: zod_1.z.string().uuid(),
+        modelId: zod_1.z.string().uuid(),
+        params: zod_1.z.object({
+            attachedFiles: zod_1.z.array(common_1.AttachedFileSchema),
+        }),
+        tokenReservationId: zod_1.z.string().uuid().optional(),
+        precalculatedPrice: zod_1.z.number().optional(),
+    });
+    ImageRecognitionCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.ImageRecognitionJobSchema);
+})(ImageRecognitionCommand || (exports.ImageRecognitionCommand = ImageRecognitionCommand = {}));

package/build/image-recognition/commands/index.js

@@ -0,0 +1,24 @@
+"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("./get-image-recognition-price.command"), exports);
+__exportStar(require("./image-recognition.command"), exports);
+__exportStar(require("./retry-image-recognition-job.command"), exports);
+__exportStar(require("./set-reaction-to-image-recognition-job.command"), exports);
+__exportStar(require("./update-image-recognition-job-title.command"), exports);
+__exportStar(require("./update-image-recognition-job-favorite.command"), exports);
+__exportStar(require("./delete-image-recognition-job-by-uuid.command"), exports);
+__exportStar(require("./delete-all-image-recognition-jobs.command"), exports);

package/build/image-recognition/commands/retry-image-recognition-job.command.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryImageRecognitionJobCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const locale_schema_1 = require("../../common/models/locale.schema");
+const models_1 = require("../models");
+const common_1 = require("../../common");
+var RetryImageRecognitionJobCommand;
+(function (RetryImageRecognitionJobCommand) {
+    RetryImageRecognitionJobCommand.RequestSchema = zod_1.z.object({
+        locale: locale_schema_1.LocaleSchema,
+        uuid: zod_1.z.string().uuid(),
+        tokenReservationId: zod_1.z.string().uuid().optional(),
+        precalculatedPrice: zod_1.z.number().optional(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        prompt: zod_1.z.string().optional(),
+        categoryId: zod_1.z.string().uuid().optional(),
+        modelId: zod_1.z.string().uuid().optional(),
+        params: zod_1.z
+            .object({
+            attachedFiles: zod_1.z.array(common_1.AttachedFileSchema),
+        })
+            .optional(),
+    });
+    RetryImageRecognitionJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.ImageRecognitionJobSchema);
+})(RetryImageRecognitionJobCommand || (exports.RetryImageRecognitionJobCommand = RetryImageRecognitionJobCommand = {}));

package/build/image-recognition/commands/set-reaction-to-image-recognition-job.command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetReactionToImageRecognitionJobCommand = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var SetReactionToImageRecognitionJobCommand;
+(function (SetReactionToImageRecognitionJobCommand) {
+    SetReactionToImageRecognitionJobCommand.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(),
+        reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
+    });
+    SetReactionToImageRecognitionJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.ImageRecognitionJobSchema);
+})(SetReactionToImageRecognitionJobCommand || (exports.SetReactionToImageRecognitionJobCommand = SetReactionToImageRecognitionJobCommand = {}));

package/build/image-recognition/commands/update-image-recognition-job-favorite.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateImageRecognitionJobFavoriteCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const image_recognition_job_schema_1 = require("../models/image-recognition-job.schema");
+var UpdateImageRecognitionJobFavoriteCommand;
+(function (UpdateImageRecognitionJobFavoriteCommand) {
+    UpdateImageRecognitionJobFavoriteCommand.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(),
+        isFavorite: zod_1.z.boolean(),
+    });
+    UpdateImageRecognitionJobFavoriteCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(image_recognition_job_schema_1.ImageRecognitionJobSchema);
+})(UpdateImageRecognitionJobFavoriteCommand || (exports.UpdateImageRecognitionJobFavoriteCommand = UpdateImageRecognitionJobFavoriteCommand = {}));

package/build/image-recognition/commands/update-image-recognition-job-title.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateImageRecognitionJobTitleCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../models");
+const common_1 = require("../../common");
+var UpdateImageRecognitionJobTitleCommand;
+(function (UpdateImageRecognitionJobTitleCommand) {
+    UpdateImageRecognitionJobTitleCommand.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(),
+    });
+    UpdateImageRecognitionJobTitleCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.ImageRecognitionJobSchema);
+})(UpdateImageRecognitionJobTitleCommand || (exports.UpdateImageRecognitionJobTitleCommand = UpdateImageRecognitionJobTitleCommand = {}));

package/build/image-recognition/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("./commands"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./queries"), exports);
+__exportStar(require("./routes"), exports);

package/build/image-recognition/models/image-recognition-category.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageRecognitionCategorySchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+exports.ImageRecognitionCategorySchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    parentId: zod_1.z.string().nullable(),
+    title: zod_1.z.string(),
+    systemPrompt: zod_1.z.string(),
+    order: zod_1.z.number(),
+    status: zod_1.z.nativeEnum(common_1.TOOL_MODEL_STATUS),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/image-recognition/models/image-recognition-config.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageRecognitionConfigSchema = void 0;
+const zod_1 = require("zod");
+const image_recognition_model_schema_1 = require("./image-recognition-model.schema");
+const image_recognition_category_schema_1 = require("./image-recognition-category.schema");
+exports.ImageRecognitionConfigSchema = zod_1.z.object({
+    models: zod_1.z.array(image_recognition_model_schema_1.ImageRecognitionModelSchema),
+    categories: zod_1.z.array(image_recognition_category_schema_1.ImageRecognitionCategorySchema),
+});

package/build/image-recognition/models/image-recognition-job.schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageRecognitionJobSchema = exports.ImageRecognitionJobParamsSchema = void 0;
+const zod_1 = require("zod");
+const tools_1 = require("../../tools");
+const common_1 = require("../../common");
+exports.ImageRecognitionJobParamsSchema = zod_1.z.object({
+    attachedFiles: zod_1.z.array(common_1.AttachedFileSchema),
+});
+exports.ImageRecognitionJobSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    prompt: zod_1.z.string().nullable(),
+    categoryId: zod_1.z.string(),
+    aiOutput: zod_1.z.string().nullable().optional(),
+    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
+    externalId: zod_1.z.string().nullable(),
+    title: zod_1.z.string(),
+    status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    error: zod_1.z.string().nullable(),
+    internalError: zod_1.z.string().nullable().optional(),
+    modelId: zod_1.z.string(),
+    price: zod_1.z.number(),
+    params: exports.ImageRecognitionJobParamsSchema,
+    attempts: zod_1.z.array(zod_1.z.any()),
+    userId: zod_1.z.string().nullable().optional(),
+    unregisteredUserId: zod_1.z.string().nullable().optional(),
+    tokenReservationId: zod_1.z.string().nullable().optional(),
+    isDeleted: zod_1.z.boolean(),
+    isFavorite: zod_1.z.boolean(),
+    createdAt: zod_1.z.date(),
+    completedAt: zod_1.z.date().nullable().optional(),
+    updatedAt: zod_1.z.date(),
+});

package/build/image-recognition/models/image-recognition-model.schema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageRecognitionModelSchema = exports.ImageRecognitionModelParamsSchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+exports.ImageRecognitionModelParamsSchema = zod_1.z.object({
+    imageAttachment: zod_1.z.object({
+        supported: zod_1.z.boolean(),
+        maxImages: zod_1.z.number(),
+        acceptedTypes: zod_1.z.array(zod_1.z.string()),
+    }),
+});
+exports.ImageRecognitionModelSchema = 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,
+    params: exports.ImageRecognitionModelParamsSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/image-recognition/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("./image-recognition-category.schema"), exports);
+__exportStar(require("./image-recognition-config.schema"), exports);
+__exportStar(require("./image-recognition-job.schema"), exports);
+__exportStar(require("./image-recognition-model.schema"), exports);

package/build/image-recognition/queries/find-image-recognition-job-by-id.query.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindImageRecognitionJobByIdQuery = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const models_1 = require("../models");
+var FindImageRecognitionJobByIdQuery;
+(function (FindImageRecognitionJobByIdQuery) {
+    FindImageRecognitionJobByIdQuery.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(),
+    });
+    FindImageRecognitionJobByIdQuery.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.ImageRecognitionJobSchema);
+})(FindImageRecognitionJobByIdQuery || (exports.FindImageRecognitionJobByIdQuery = FindImageRecognitionJobByIdQuery = {}));

package/build/image-recognition/queries/find-image-recognition-jobs.query.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindImageRecognitionJobsQuery = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+const tools_1 = require("../../tools");
+var FindImageRecognitionJobsQuery;
+(function (FindImageRecognitionJobsQuery) {
+    FindImageRecognitionJobsQuery.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(),
+        isFavorite: zod_1.z.coerce.boolean().optional(),
+        createdAtSortOrder: zod_1.z.nativeEnum(tools_1.JOB_SORT).optional().default(tools_1.JOB_SORT.DESC),
+        status: zod_1.z.nativeEnum(tools_1.JOB_STATUS).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'],
+    });
+    FindImageRecognitionJobsQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.object({
+        data: zod_1.z.array(models_1.ImageRecognitionJobSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+        total: zod_1.z.number(),
+    }));
+})(FindImageRecognitionJobsQuery || (exports.FindImageRecognitionJobsQuery = FindImageRecognitionJobsQuery = {}));

package/build/image-recognition/queries/get-image-recognition-config.query.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetImageRecognitionConfigQuery = void 0;
+const common_1 = require("../../common");
+const models_1 = require("../models");
+var GetImageRecognitionConfigQuery;
+(function (GetImageRecognitionConfigQuery) {
+    GetImageRecognitionConfigQuery.RequestSchema = common_1.LocaleRequestSchema;
+    GetImageRecognitionConfigQuery.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.ImageRecognitionConfigSchema);
+})(GetImageRecognitionConfigQuery || (exports.GetImageRecognitionConfigQuery = GetImageRecognitionConfigQuery = {}));

package/build/image-recognition/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("./get-image-recognition-config.query"), exports);
+__exportStar(require("./find-image-recognition-job-by-id.query"), exports);
+__exportStar(require("./find-image-recognition-jobs.query"), exports);

package/build/image-recognition/routes/image-recognition.amqp.routes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMAGE_RECOGNITION_AMQP_ROUTES = void 0;
+exports.IMAGE_RECOGNITION_AMQP_ROUTES = {
+    EXECUTE: 'tools.image-recognition.execute.rpc',
+    GET_PRICE: 'tools.image-recognition.get-price.rpc',
+    CONFIG: 'tools.image-recognition.config.rpc',
+    GET_JOB: 'tools.image-recognition.jobs.get.rpc',
+    LIST_JOBS: 'tools.image-recognition.jobs.list.rpc',
+    SET_REACTION: 'tools.image-recognition.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.image-recognition.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.image-recognition.jobs.update-favorite.rpc',
+    SOFT_DELETE: 'tools.image-recognition.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.image-recognition.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.image-recognition.jobs.retry.rpc',
+};

package/build/image-recognition/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("./image-recognition.amqp.routes"), exports);

package/build/index.js

@@ -60,6 +60,7 @@ __exportStar(require("./spell-corrector"), exports);
 __exportStar(require("./html-page-builder"), exports);
 __exportStar(require("./tool-workspace"), exports);
 __exportStar(require("./diagrams"), exports);
+__exportStar(require("./image-recognition"), exports);
 const common = __importStar(require("./common"));
 const paraphrase = __importStar(require("./paraphrase"));
 const tools = __importStar(require("./tools"));
@@ -83,6 +84,7 @@ const htmlPageBuilder = __importStar(require("./html-page-builder"));
 const accountMerge = __importStar(require("./account-merge"));
 const toolWorkspace = __importStar(require("./tool-workspace"));
 const diagrams = __importStar(require("./diagrams"));
+const imageRecognition = __importStar(require("./image-recognition"));
 var ToolService;
 (function (ToolService) {
     ToolService.Common = common;
@@ -108,4 +110,5 @@ var ToolService;
     ToolService.AccountMerge = accountMerge;
     ToolService.ToolWorkspace = toolWorkspace;
     ToolService.Diagrams = diagrams;
+    ToolService.ImageRecognition = imageRecognition;
 })(ToolService || (exports.ToolService = ToolService = {}));

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

@@ -20,4 +20,5 @@ var TOOL_CONTENT_TYPE;
     TOOL_CONTENT_TYPE["SPELL_CORRECTOR"] = "SPELL_CORRECTOR";
     TOOL_CONTENT_TYPE["DIAGRAMS"] = "DIAGRAMS";
     TOOL_CONTENT_TYPE["HTML_PAGE_BUILDER"] = "HTML_PAGE_BUILDER";
+    TOOL_CONTENT_TYPE["IMAGE_RECOGNITION"] = "IMAGE_RECOGNITION";
 })(TOOL_CONTENT_TYPE || (exports.TOOL_CONTENT_TYPE = TOOL_CONTENT_TYPE = {}));

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

@@ -22,4 +22,5 @@ var TOOL_TYPE;
     TOOL_TYPE["SOLVING_EDU_TASK"] = "SOLVING_EDU_TASK";
     TOOL_TYPE["DIAGRAMS"] = "DIAGRAMS";
     TOOL_TYPE["HTML_PAGE_BUILDER"] = "HTML_PAGE_BUILDER";
+    TOOL_TYPE["IMAGE_RECOGNITION"] = "IMAGE_RECOGNITION";
 })(TOOL_TYPE || (exports.TOOL_TYPE = TOOL_TYPE = {}));

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

@@ -19,6 +19,7 @@ const solving_edu_task_1 = require("../../solving-edu-task");
 const spell_corrector_1 = require("../../spell-corrector");
 const diagrams_1 = require("../../diagrams");
 const models_2 = require("../../html-page-builder/models");
+const image_recognition_1 = require("../../image-recognition");
 exports.GlobalToolsConfigSchema = zod_1.z.object({
     [enums_1.TOOL_CONTENT_TYPE.VIDEO]: video_1.VideoConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.MUSIC]: music_1.MusicConfigSchema,
@@ -36,4 +37,5 @@ exports.GlobalToolsConfigSchema = zod_1.z.object({
     [enums_1.TOOL_CONTENT_TYPE.SPELL_CORRECTOR]: spell_corrector_1.SpellCorrectorToolConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.DIAGRAMS]: diagrams_1.DiagramsConfigSchema,
     [enums_1.TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER]: models_2.HtmlPageBuilderConfigSchema,
+    [enums_1.TOOL_CONTENT_TYPE.IMAGE_RECOGNITION]: image_recognition_1.ImageRecognitionConfigSchema,
 });

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

@@ -20,6 +20,7 @@ const solving_edu_task_1 = require("../../solving-edu-task");
 const spell_corrector_1 = require("../../spell-corrector");
 const diagrams_1 = require("../../diagrams");
 const models_2 = require("../../html-page-builder/models");
+const image_recognition_1 = require("../../image-recognition");
 // Discriminated union array: Tools with their configs
 exports.ToolWithConfigSchema = zod_1.z.discriminatedUnion('contentType', [
     tool_schema_1.ToolSchema.merge(zod_1.z.object({
@@ -86,5 +87,9 @@ exports.ToolWithConfigSchema = zod_1.z.discriminatedUnion('contentType', [
         contentType: zod_1.z.literal(enums_1.TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER),
         config: models_2.HtmlPageBuilderConfigSchema,
     })),
+    tool_schema_1.ToolSchema.merge(zod_1.z.object({
+        contentType: zod_1.z.literal(enums_1.TOOL_CONTENT_TYPE.IMAGE_RECOGNITION),
+        config: image_recognition_1.ImageRecognitionConfigSchema,
+    })),
 ]);
 exports.ToolsWithConfigsSchema = zod_1.z.array(exports.ToolWithConfigSchema);

package/image-recognition/commands/delete-all-image-recognition-jobs.command.ts

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

package/image-recognition/commands/delete-image-recognition-job-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteImageRecognitionJobByUuidCommand {
+    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/image-recognition/commands/get-image-recognition-price.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetImageRecognitionPriceCommand {
+    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/image-recognition/commands/image-recognition.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageRecognitionJobSchema } from '../models';
+import { AttachedFileSchema, LocaleSchema } from '../../common';
+
+export namespace ImageRecognitionCommand {
+    export const RequestSchema = z.object({
+        locale: LocaleSchema,
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string().optional(),
+        categoryId: z.string().uuid(),
+        modelId: z.string().uuid(),
+        params: z.object({
+            attachedFiles: z.array(AttachedFileSchema),
+        }),
+        tokenReservationId: z.string().uuid().optional(),
+        precalculatedPrice: z.number().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ImageRecognitionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-recognition/commands/index.ts

@@ -0,0 +1,8 @@
+export * from './get-image-recognition-price.command';
+export * from './image-recognition.command';
+export * from './retry-image-recognition-job.command';
+export * from './set-reaction-to-image-recognition-job.command';
+export * from './update-image-recognition-job-title.command';
+export * from './update-image-recognition-job-favorite.command';
+export * from './delete-image-recognition-job-by-uuid.command';
+export * from './delete-all-image-recognition-jobs.command';

package/image-recognition/commands/retry-image-recognition-job.command.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { LocaleSchema } from '../../common/models/locale.schema';
+import { ImageRecognitionJobSchema } from '../models';
+import { AttachedFileSchema } from '../../common';
+
+export namespace RetryImageRecognitionJobCommand {
+    export const RequestSchema = z.object({
+        locale: LocaleSchema,
+        uuid: z.string().uuid(),
+        tokenReservationId: z.string().uuid().optional(),
+        precalculatedPrice: z.number().optional(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string().optional(),
+        categoryId: z.string().uuid().optional(),
+        modelId: z.string().uuid().optional(),
+        params: z
+            .object({
+                attachedFiles: z.array(AttachedFileSchema),
+            })
+            .optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ImageRecognitionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-recognition/commands/set-reaction-to-image-recognition-job.command.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../common';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageRecognitionJobSchema } from '../models';
+
+export namespace SetReactionToImageRecognitionJobCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ImageRecognitionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-recognition/commands/update-image-recognition-job-favorite.command.ts

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

package/image-recognition/commands/update-image-recognition-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ImageRecognitionJobSchema } from '../models';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdateImageRecognitionJobTitleCommand {
+    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(ImageRecognitionJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-recognition/index.ts

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

package/image-recognition/models/image-recognition-category.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { TOOL_MODEL_STATUS } from '../../common';
+
+export const ImageRecognitionCategorySchema = z.object({
+    uuid: z.string(),
+    parentId: z.string().nullable(),
+    title: z.string(),
+    systemPrompt: z.string(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageRecognitionCategory = z.infer<typeof ImageRecognitionCategorySchema>;

package/image-recognition/models/image-recognition-config.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ImageRecognitionModelSchema } from './image-recognition-model.schema';
+import { ImageRecognitionCategorySchema } from './image-recognition-category.schema';
+
+export const ImageRecognitionConfigSchema = z.object({
+    models: z.array(ImageRecognitionModelSchema),
+    categories: z.array(ImageRecognitionCategorySchema),
+});
+
+export type ImageRecognitionConfig = z.infer<typeof ImageRecognitionConfigSchema>;

package/image-recognition/models/image-recognition-job.schema.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { AttachedFileSchema, USER_REACTION } from '../../common';
+
+export const ImageRecognitionJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedFileSchema),
+});
+
+export type ImageRecognitionJobParams = z.infer<typeof ImageRecognitionJobParamsSchema>;
+
+export const ImageRecognitionJobSchema = z.object({
+    uuid: z.string(),
+    prompt: z.string().nullable(),
+    categoryId: z.string(),
+    aiOutput: z.string().nullable().optional(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    externalId: z.string().nullable(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    internalError: z.string().nullable().optional(),
+    modelId: z.string(),
+    price: z.number(),
+    params: ImageRecognitionJobParamsSchema,
+    attempts: z.array(z.any()),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    tokenReservationId: z.string().nullable().optional(),
+    isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
+    createdAt: z.date(),
+    completedAt: z.date().nullable().optional(),
+    updatedAt: z.date(),
+});
+
+export type ImageRecognitionJob = z.infer<typeof ImageRecognitionJobSchema>;

package/image-recognition/models/image-recognition-model.schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
+
+export const ImageRecognitionModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type ImageRecognitionModelParams = z.infer<typeof ImageRecognitionModelParamsSchema>;
+
+export const ImageRecognitionModelSchema = 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,
+    params: ImageRecognitionModelParamsSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageRecognitionModel = z.infer<typeof ImageRecognitionModelSchema>;

package/image-recognition/models/index.ts

@@ -0,0 +1,4 @@
+export * from './image-recognition-category.schema';
+export * from './image-recognition-config.schema';
+export * from './image-recognition-job.schema';
+export * from './image-recognition-model.schema';

package/image-recognition/queries/find-image-recognition-job-by-id.query.ts

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

package/image-recognition/queries/find-image-recognition-jobs.query.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageRecognitionJobSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
+
+export namespace FindImageRecognitionJobsQuery {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+            title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).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(ImageRecognitionJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+            total: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-recognition/queries/get-image-recognition-config.query.ts

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

package/image-recognition/queries/index.ts

@@ -0,0 +1,3 @@
+export * from './get-image-recognition-config.query';
+export * from './find-image-recognition-job-by-id.query';
+export * from './find-image-recognition-jobs.query';

package/image-recognition/routes/image-recognition.amqp.routes.ts

@@ -0,0 +1,13 @@
+export const IMAGE_RECOGNITION_AMQP_ROUTES = {
+    EXECUTE: 'tools.image-recognition.execute.rpc',
+    GET_PRICE: 'tools.image-recognition.get-price.rpc',
+    CONFIG: 'tools.image-recognition.config.rpc',
+    GET_JOB: 'tools.image-recognition.jobs.get.rpc',
+    LIST_JOBS: 'tools.image-recognition.jobs.list.rpc',
+    SET_REACTION: 'tools.image-recognition.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.image-recognition.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.image-recognition.jobs.update-favorite.rpc',
+    SOFT_DELETE: 'tools.image-recognition.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.image-recognition.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.image-recognition.jobs.retry.rpc',
+} as const;

package/image-recognition/routes/index.ts

@@ -0,0 +1 @@
+export * from './image-recognition.amqp.routes';

package/index.ts

@@ -21,6 +21,7 @@ export * from './spell-corrector';
 export * from './html-page-builder';
 export * from './tool-workspace';
 export * from './diagrams';
+export * from './image-recognition';
 
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -45,6 +46,7 @@ import * as htmlPageBuilder from './html-page-builder';
 import * as accountMerge from './account-merge';
 import * as toolWorkspace from './tool-workspace';
 import * as diagrams from './diagrams';
+import * as imageRecognition from './image-recognition';
 
 export namespace ToolService {
     export import Common = common;
@@ -70,4 +72,5 @@ export namespace ToolService {
     export import AccountMerge = accountMerge;
     export import ToolWorkspace = toolWorkspace;
     export import Diagrams = diagrams;
+    export import ImageRecognition = imageRecognition;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {
@@ -15,4 +15,4 @@
     "@purpleschool/rugpt-lib-common": "^0.0.21",
     "zod": "^3.25.67"
   }
-}
+}

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

@@ -16,4 +16,5 @@ export enum TOOL_CONTENT_TYPE {
     SPELL_CORRECTOR = 'SPELL_CORRECTOR',
     DIAGRAMS = 'DIAGRAMS',
     HTML_PAGE_BUILDER = 'HTML_PAGE_BUILDER',
+    IMAGE_RECOGNITION = 'IMAGE_RECOGNITION',
 }

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

@@ -18,4 +18,5 @@ export enum TOOL_TYPE {
     SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
     DIAGRAMS = 'DIAGRAMS',
     HTML_PAGE_BUILDER = 'HTML_PAGE_BUILDER',
+    IMAGE_RECOGNITION = 'IMAGE_RECOGNITION',
 }

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

@@ -16,6 +16,7 @@ import { SolvingEduTaskConfigSchema } from '../../solving-edu-task';
 import { SpellCorrectorToolConfigSchema } from '../../spell-corrector';
 import { DiagramsConfigSchema } from '../../diagrams';
 import { HtmlPageBuilderConfigSchema } from '../../html-page-builder/models';
+import { ImageRecognitionConfigSchema } from '../../image-recognition';
 
 export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.VIDEO]: VideoConfigSchema,
@@ -34,6 +35,7 @@ export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.SPELL_CORRECTOR]: SpellCorrectorToolConfigSchema,
     [TOOL_CONTENT_TYPE.DIAGRAMS]: DiagramsConfigSchema,
     [TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER]: HtmlPageBuilderConfigSchema,
+    [TOOL_CONTENT_TYPE.IMAGE_RECOGNITION]: ImageRecognitionConfigSchema,
 });
 
 export type GlobalToolsConfig = z.infer<typeof GlobalToolsConfigSchema>;

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

@@ -17,6 +17,7 @@ import { SolvingEduTaskConfigSchema } from '../../solving-edu-task';
 import { SpellCorrectorToolConfigSchema } from '../../spell-corrector';
 import { DiagramsConfigSchema } from '../../diagrams';
 import { HtmlPageBuilderConfigSchema } from '../../html-page-builder/models';
+import { ImageRecognitionConfigSchema } from '../../image-recognition';
 
 // Discriminated union array: Tools with their configs
 export const ToolWithConfigSchema = z.discriminatedUnion('contentType', [
@@ -116,6 +117,12 @@ export const ToolWithConfigSchema = z.discriminatedUnion('contentType', [
             config: HtmlPageBuilderConfigSchema,
         }),
     ),
+    ToolSchema.merge(
+        z.object({
+            contentType: z.literal(TOOL_CONTENT_TYPE.IMAGE_RECOGNITION),
+            config: ImageRecognitionConfigSchema,
+        }),
+    ),
 ]);
 
 export type ToolWithConfig = z.infer<typeof ToolWithConfigSchema>;