@purpleschool/gptbot-tools 0.0.78 → 0.0.79-ai-proxy

package/common/errors/errors.ts

@@ -101,6 +101,21 @@ export const ERRORS = {
             message: 'Задание на перефразирование не найдено',
             httpCode: 404,
         },
+        DELETE_ERROR: {
+            code: 'PARAPHRASE_JOB.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении задания на перефразирование',
+            httpCode: 500,
+        },
+        NOT_AN_OWNER: {
+            code: 'PARAPHRASE_JOB.NOT_AN_OWNER',
+            message: 'Пользователь не является владельцем задания на перефразирование',
+            httpCode: 403,
+        },
+        NOT_IN_FAILED_STATE_TO_RETRY: {
+            code: 'PARAPHRASE_JOB.NOT_IN_FAILED_STATE_TO_RETRY',
+            message: 'Задание на перефразирование не в состоянии "failed". Невозможно повторить',
+            httpCode: 400,
+        },
     },
     S3: {
         GET_FILE_STREAM_ERROR: {
@@ -659,6 +674,11 @@ export const ERRORS = {
             message: 'Произошла ошибка при удалении задания на генерацию видео',
             httpCode: 500,
         },
+        UPDATE_ERROR: {
+            code: 'VIDEO_JOB.UPDATE_ERROR',
+            message: 'Произошла ошибка при обновлении задания на генерацию видео',
+            httpCode: 500,
+        },
     },
     WRITER_DOCUMENT: {
         SET_REACTION_TO_WRITER_DOCUMENT_ERROR: {
@@ -935,6 +955,11 @@ export const ERRORS = {
             message: 'Произошла ошибка при удалении задания на редактирование картинки',
             httpCode: 500,
         },
+        UPDATE_ERROR: {
+            code: 'IMAGE_EDITOR_JOB.UPDATE_ERROR',
+            message: 'Произошла ошибка при обновлении задания на редактирование картинки',
+            httpCode: 500,
+        },
     },
     VIDEO_EDITOR: {
         AI_ERROR: {
@@ -1034,6 +1059,11 @@ export const ERRORS = {
             message: 'Произошла ошибка при удалении задания на редактирование видео',
             httpCode: 500,
         },
+        UPDATE_ERROR: {
+            code: 'VIDEO_EDITOR_JOB.UPDATE_ERROR',
+            message: 'Произошла ошибка при обновлении задания на редактирование видео',
+            httpCode: 500,
+        },
     },
     MUSIC_EDITOR: {
         AI_ERROR: {
@@ -1202,6 +1232,126 @@ export const ERRORS = {
             httpCode: 500,
         },
     },
+    IMAGE_GENERATION: {
+        AI_ERROR: {
+            code: 'IMAGE_GENERATION.AI_ERROR',
+            message: 'Произошла ошибка во время запроса к ИИ',
+            httpCode: 500,
+        },
+        INSUFFICIENT_BALANCE: {
+            code: 'IMAGE_GENERATION.INSUFFICIENT_BALANCE',
+            message: 'У пользователя недостаточно средств',
+            httpCode: 400,
+        },
+        INVALID_PARAMS: {
+            code: 'IMAGE_GENERATION.INVALID_PARAMS',
+            message: 'Некорректные параметры изображения',
+            httpCode: 400,
+        },
+        DELETE_ERROR: {
+            code: 'IMAGE_GENERATION.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении генерации изображения',
+            httpCode: 500,
+        },
+        MAX_PROMPT_LENGTH_EXCEEDED: {
+            code: 'IMAGE_GENERATION.MAX_PROMPT_LENGTH_EXCEEDED',
+            message: 'Превышена максимальная длина запроса',
+            httpCode: 400,
+        },
+        POLL_TIMEOUT: {
+            code: 'IMAGE_GENERATION.POLL_TIMEOUT',
+            message: 'Превышено время ожидания генерации изображения',
+            httpCode: 500,
+        },
+        IMAGE_ATTACHMENT_NOT_SUPPORTED: {
+            code: 'IMAGE_GENERATION.IMAGE_ATTACHMENT_NOT_SUPPORTED',
+            message: 'Выбранная модель не поддерживает вложение изображений',
+            httpCode: 400,
+        },
+        TOO_MANY_ATTACHED_IMAGES: {
+            code: 'IMAGE_GENERATION.TOO_MANY_ATTACHED_IMAGES',
+            message: 'Слишком много вложенных изображений',
+            httpCode: 400,
+        },
+    },
+    IMAGE_GENERATION_MODEL: {
+        SAVE_ERROR: {
+            code: 'IMAGE_GENERATION_MODEL.SAVE_ERROR',
+            message: 'Произошла ошибка при сохранении модели для генерации изображений',
+            httpCode: 500,
+        },
+        FIND_ERROR: {
+            code: 'IMAGE_GENERATION_MODEL.FIND_ERROR',
+            message: 'Произошла ошибка при поиске модели для генерации изображений',
+            httpCode: 500,
+        },
+        NOT_FOUND: {
+            code: 'IMAGE_GENERATION_MODEL.NOT_FOUND',
+            message: 'Модель для генерации изображений не найдена',
+            httpCode: 404,
+        },
+        MODEL_INACTIVE: {
+            code: 'IMAGE_GENERATION_MODEL.MODEL_INACTIVE',
+            message: 'Модель для генерации изображений неактивна',
+            httpCode: 400,
+        },
+    },
+    IMAGE_GENERATION_JOB: {
+        SAVE_ERROR: {
+            code: 'IMAGE_GENERATION_JOB.SAVE_ERROR',
+            message: 'Произошла ошибка при сохранении задания на генерацию изображения',
+            httpCode: 500,
+        },
+        FIND_ERROR: {
+            code: 'IMAGE_GENERATION_JOB.FIND_ERROR',
+            message: 'Произошла ошибка при поиске задания на генерацию изображения',
+            httpCode: 500,
+        },
+        NOT_FOUND: {
+            code: 'IMAGE_GENERATION_JOB.NOT_FOUND',
+            message: 'Задание на генерацию изображения не найдено',
+            httpCode: 404,
+        },
+        NOT_AN_OWNER: {
+            code: 'IMAGE_GENERATION_JOB.NOT_AN_OWNER',
+            message: 'Пользователь не является владельцем задания на генерацию изображения',
+            httpCode: 403,
+        },
+        DELETE_ERROR: {
+            code: 'IMAGE_GENERATION_JOB.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении задания на генерацию изображения',
+            httpCode: 500,
+        },
+        UPDATE_ERROR: {
+            code: 'IMAGE_GENERATION_JOB.UPDATE_ERROR',
+            message: 'Произошла ошибка при обновлении задания на генерацию изображения',
+            httpCode: 500,
+        },
+    },
+    IMAGE_GENERATION_PRESET: {
+        FIND_ERROR: {
+            code: 'IMAGE_GENERATION_PRESET.FIND_ERROR',
+            message: 'Произошла ошибка при поиске пресета генерации изображения',
+            httpCode: 500,
+        },
+        NOT_FOUND: {
+            code: 'IMAGE_GENERATION_PRESET.NOT_FOUND',
+            message: 'Пресет генерации изображения не найден',
+            httpCode: 404,
+        },
+    },
+    AI_VENDOR: {
+        FIND_ERROR: {
+            code: 'AI_VENDOR.FIND_ERROR',
+            message: 'Произошла ошибка при поиске поставщика ИИ',
+            httpCode: 500,
+        },
+        NOT_FOUND: {
+            code: 'AI_VENDOR.NOT_FOUND',
+            message: 'Поставщик ИИ не найден',
+            httpCode: 404,
+        },
+    },
     CONTENT_POLICY: {
         PHOTOREALISTIC_PEOPLE: {
             code: 'CONTENT_POLICY.PHOTOREALISTIC_PEOPLE',
@@ -1264,4 +1414,12 @@ export const ERRORS = {
             httpCode: 400,
         },
     },
+    // KIE
+    KIE: {
+        AI_ERROR: {
+            code: 'KIE.GET_TASK_BY_ID_RESPONSE_ERROR',
+            message: 'Произошла ошибка при получении ответа от KIE',
+            httpCode: 500,
+        },
+    },
 } as const;

package/common/models/attached-file.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const AttachedFileSchema = z.object({
+    uuid: z.string(),
+    url: z.string(),
+    name: z.string(),
+    mimeType: z.string(),
+    type: z.string(),
+    size: z.number(),
+    duration: z.number().optional().nullable(),
+});

package/common/models/index.ts

@@ -1,2 +1,3 @@
 export * from './command-response.schema';
 export * from './icon-variants.schema';
+export * from './attached-file.schema';

package/image-editor/commands/image-editor.command.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { ImageEditorJobSchema } from '../models';
+import { AttachedFileSchema } from '../../common';
 
 export namespace ImageEditorCommand {
     export const RequestSchema = z.object({
@@ -10,9 +11,10 @@ export namespace ImageEditorCommand {
         userBalance: z.number(),
         modelId: z.string(),
         params: z.object({
-            imageUrls: z.array(z.string()),
+            attachedFiles: z.array(AttachedFileSchema),
             systemPromptId: z.string().optional(),
         }),
+        userHasActiveSubscriptionOrProduct: z.boolean(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { ImageEditorJobSchema } from '../models';
+import { ImageEditorJobParamsSchema, ImageEditorJobSchema } from '../models';
 
 export namespace RetryImageEditorJobCommand {
     export const RequestSchema = z.object({
@@ -8,6 +8,10 @@ export namespace RetryImageEditorJobCommand {
         userBalance: z.number(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        userHasActiveSubscriptionOrProduct: z.boolean(),
+        modelId: z.string().optional(),
+        prompt: z.string().optional(),
+        params: ImageEditorJobParamsSchema.optional(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

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

@@ -4,12 +4,25 @@ import { ImageEditorJobSchema } from '../models';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToImageEditorJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    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(ImageEditorJobSchema);

package/image-editor/enums/image-editor-model-type.enum.ts

@@ -1,3 +1,5 @@
 export enum IMAGE_EDITOR_MODEL_TYPE {
     NANO_BANANA_EDIT = 'NANO_BANANA_EDIT',
+    RECRAFT_REMOVE_BACKGROUND = 'RECRAFT_REMOVE_BACKGROUND',
+    NANO_BANANA_PRO_EDIT = 'NANO_BANANA_PRO_EDIT',
 }

package/image-editor/enums/image-editor-strategy.enum.ts

@@ -1,4 +1,8 @@
 export enum IMAGE_EDITING_STRATEGY {
     NANO_BANANA_POLLING = 'NANO_BANANA_POLLING',
     NANO_BANANA_CALLBACK = 'NANO_BANANA_CALLBACK',
+    RECRAFT_REMOVE_BACKGROUND_CALLBACK = 'RECRAFT_REMOVE_BACKGROUND_CALLBACK',
+    RECRAFT_REMOVE_BACKGROUND_POLLING = 'RECRAFT_REMOVE_BACKGROUND_POLLING',
+    NANO_BANANA_PRO_CALLBACK = 'NANO_BANANA_PRO_CALLBACK',
+    NANO_BANANA_PRO_POLLING = 'NANO_BANANA_PRO_POLLING',
 }

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

@@ -26,6 +26,7 @@ export const SystemPromptSchema = z.object({
         })
         .nullable(),
     order: z.number(),
+    placeholder: z.string().nullable(),
 });
 
 export const ImageEditorActionGroup = z.object({

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

@@ -1,8 +1,9 @@
 import { z } from 'zod';
 import { JOB_STATUS } from '../../tools';
-import { USER_REACTION } from '../../common';
+import { AttachedFileSchema, USER_REACTION } from '../../common';
 
 export const ImageEditorJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedFileSchema).optional(),
     imageUrls: z.array(z.string()).optional(),
     systemPromptId: z.string().optional(),
 });
@@ -13,6 +14,7 @@ export const ImageEditorJobSchema = z.object({
     uuid: z.string(),
     prompt: z.string(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     title: z.string(),
     status: z.nativeEnum(JOB_STATUS),

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

@@ -12,6 +12,21 @@ export const ImageEditorModelParamsSchema = z.object({
 
 export type ImageEditorModelParams = z.infer<typeof ImageEditorModelParamsSchema>;
 
+export const ImageEditorModelPricingRuleConditionSchema = z.object({
+    withoutSub: z.boolean().optional(),
+});
+export type ImageEditorModelPricingRuleCondition = z.infer<
+    typeof ImageEditorModelPricingRuleConditionSchema
+>;
+
+export const ImageEditorModelPricingRulesSchema = z.array(
+    z.object({
+        condition: ImageEditorModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type ImageEditorModelPricingRules = z.infer<typeof ImageEditorModelPricingRulesSchema>;
+
 export const ImageEditorModelSchema = z.object({
     uuid: z.string(),
     title: z.string(),
@@ -24,6 +39,7 @@ export const ImageEditorModelSchema = z.object({
     strategy: z.nativeEnum(IMAGE_EDITING_STRATEGY),
     maxInputLength: z.number(),
     params: ImageEditorModelParamsSchema,
+    pricingRules: ImageEditorModelPricingRulesSchema,
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/image-editor/routes/image-editor.http.routes.ts

@@ -2,4 +2,5 @@ export const IMAGE_EDITOR_CONTROLLER = 'image-editor';
 
 export const IMAGE_EDITOR_ROUTES = {
     KIE_NANO_BANANA_CALLBACK: '/kie/nano-banana/callback',
+    KIE_RECRAFT_REMOVE_BACKGROUND: '/kie/recraft-remove-background/callback',
 };

package/image-generation/commands/execute-image-generation.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageGenerationJobSchema, ImageGenerationRequestParamsSchema } from '../models';
+
+export namespace ExecuteImageGenerationCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string(),
+        userBalance: z.number(),
+        modelId: z.string().uuid(),
+        params: ImageGenerationRequestParamsSchema,
+        presetId: z.string().uuid().nullable().optional(),
+        userHasActiveSubscriptionOrProduct: z.boolean(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ImageGenerationJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-generation/commands/forward-image-generation-job.command.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageGenerationJobSchema, ImageGenerationJobParamsSchema } from '../models';
+import { JOB_STATUS } from '../../tools/enums/job-status.enum';
+import { USER_REACTION } from '../../common/enums/user-reaction.enum';
+
+export namespace ForwardImageGenerationJobCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        prompt: z.string(),
+        title: z.string(),
+        status: z.nativeEnum(JOB_STATUS),
+        error: z.string().nullable(),
+        price: z.number(),
+        reaction: z.nativeEnum(USER_REACTION).nullable(),
+        externalId: z.string().nullable(),
+        output: z.array(z.string()),
+        params: ImageGenerationJobParamsSchema,
+        modelId: z.string().uuid(),
+        presetId: z.string().uuid().nullable().optional(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        isDeleted: z.boolean(),
+        internalError: z.string().nullable(),
+        createdAt: z.coerce.date(),
+        updatedAt: z.coerce.date(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ImageGenerationJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/image-generation/commands/index.ts

@@ -0,0 +1,7 @@
+export * from './execute-image-generation.command';
+export * from './forward-image-generation-job.command';
+export * from './save-image-generation-job.command';
+export * from './soft-delete-image-generation-job-by-uuid.command';
+export * from './soft-delete-image-generation-jobs-by-criteria.command';
+export * from './set-reaction-to-image-generation-job.command';
+export * from './update-image-generation-job-title.command';

package/image-generation/commands/save-image-generation-job.command.ts

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

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../common';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageGenerationJobSchema } from '../models';
+
+export namespace SetReactionToImageGenerationJobCommand {
+    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(ImageGenerationJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

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

package/image-generation/commands/soft-delete-image-generation-jobs-by-criteria.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace SoftDeleteImageGenerationJobsByCriteriaCommand {
+    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-generation/commands/update-image-generation-job-title.command.ts

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

package/image-generation/enums/image-generation-model-strategy.enum.ts

@@ -0,0 +1,24 @@
+export enum IMAGE_GENERATION_MODEL_STRATEGY {
+    // Together AI Models
+    FLUX_IMAGE_GENERATION = 'FLUX_IMAGE_GENERATION',
+    FLUX_DEV_IMAGE_GENERATION = 'FLUX_DEV_IMAGE_GENERATION',
+    STABLE_DIFFUSION_IMAGE_GENERATION = 'STABLE_DIFFUSION_IMAGE_GENERATION',
+
+    // Grok AI
+    GROK_IMAGE_GENERATION = 'GROK_IMAGE_GENERATION',
+
+    // OpenAI
+    DALLE_IMAGE_GENERATION = 'DALLE_IMAGE_GENERATION',
+    OPENAI_IMAGE_1_GENERATION = 'OPENAI_IMAGE_1_GENERATION',
+
+    // Google AI
+    GEMINI_IMAGE_GENERATION = 'GEMINI_IMAGE_GENERATION',
+    IMAGEN_IMAGE_GENERATION = 'IMAGEN_IMAGE_GENERATION',
+
+    // Midjourney
+    MIDJOURNEY_IMAGE_GENERATION = 'MIDJOURNEY_IMAGE_GENERATION',
+    NANO_BANANA_IMAGE_GENERATION = 'NANO_BANANA_IMAGE_GENERATION',
+
+    // Flux
+    KIE_FLUX_IMAGE_GENERATION = 'KIE_FLUX_IMAGE_GENERATION',
+}

package/image-generation/enums/image-generation-models.enum.ts

@@ -0,0 +1,4 @@
+export enum IMAGE_GENERATION_MODELS {
+    NANO_BANANA = 'google/nano-banana',
+    NANO_BANANA_PRO = 'nano-banana-pro',
+}

package/image-generation/enums/image-generation-resolution.enum.ts

@@ -0,0 +1,5 @@
+export enum IMAGE_GENERATION_RESOLUTION {
+    LOW = '1K',
+    MEDIUM = '2K',
+    HIGH = '4K',
+}

package/image-generation/enums/index.ts

@@ -0,0 +1,3 @@
+export * from './image-generation-model-strategy.enum';
+export * from './image-generation-resolution.enum';
+export * from './image-generation-models.enum';

package/image-generation/index.ts

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

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ImageGenerationModelSchema } from './image-generation-model.schema';
+import { ImageGenerationPresetSchema } from './image-generation-preset.schema';
+import { AiVendorSchema } from '../../ai-vendor';
+
+export const ImageGenerationConfigSchema = z.object({
+    vendors: z.array(AiVendorSchema),
+    models: z.array(ImageGenerationModelSchema),
+    presets: z.array(ImageGenerationPresetSchema),
+});
+export type ImageGenerationConfig = z.infer<typeof ImageGenerationConfigSchema>;

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { AttachedFileSchema, USER_REACTION } from '../../common';
+import { IMAGE_GENERATION_RESOLUTION } from '../enums';
+
+export const ImageGenerationJobParamsSchema = z.object({
+    aspectRatio: z.string(),
+    attachedFiles: z.array(AttachedFileSchema),
+    enhancePrompt: z.boolean(),
+    resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
+});
+export type ImageGenerationJobParams = z.infer<typeof ImageGenerationJobParamsSchema>;
+
+export const ImageGenerationJobSchema = z.object({
+    uuid: z.string(),
+    prompt: z.string(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    price: z.number(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    externalId: z.string().nullable(),
+    params: ImageGenerationJobParamsSchema,
+    output: z.array(z.string()),
+    presetId: z.string().nullable().optional(),
+    modelId: z.string(),
+    attempts: z.array(z.any()),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    isDeleted: z.boolean(),
+    internalError: z.string().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageGenerationJob = z.infer<typeof ImageGenerationJobSchema>;