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

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>;

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

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { AttachedFileSchema, IconVariantsSchema, TOOL_MODEL_STATUS } from '../../common';
+import { IMAGE_GENERATION_MODEL_STRATEGY, IMAGE_GENERATION_RESOLUTION } from '../enums';
+
+export const ImageGenerationRequestParamsSchema = z.object({
+    aspectRatio: z.string(),
+    attachedFiles: z.array(AttachedFileSchema),
+    enhancePrompt: z.boolean(),
+    resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
+});
+export type ImageGenerationRequestParams = z.infer<typeof ImageGenerationRequestParamsSchema>;
+
+export const ImageGenerationModelParamsSchema = z.object({
+    aspectRatio: z.record(
+        z.string(),
+        z.object({
+            width: z.number(),
+            height: z.number(),
+        }),
+    ),
+    quality: z.string().optional(),
+    resolution: z
+        .object({
+            options: z.array(z.nativeEnum(IMAGE_GENERATION_RESOLUTION)),
+        })
+        .optional(),
+});
+export type ImageGenerationModelParams = z.infer<typeof ImageGenerationModelParamsSchema>;
+
+export const ImageModelPricingRuleConditionSchema = z.object({
+    resolution: z.string().optional(),
+    withoutSub: z.boolean().optional(),
+});
+export type ImageModelPricingRuleCondition = z.infer<typeof ImageModelPricingRuleConditionSchema>;
+
+export const ImageModelPricingRulesSchema = z.array(
+    z.object({
+        condition: ImageModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type ImageModelPricingRules = z.infer<typeof ImageModelPricingRulesSchema>;
+
+export const ImageGenerationModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    price: z.number(),
+    order: z.number(),
+    params: ImageGenerationModelParamsSchema,
+    strategy: z.nativeEnum(IMAGE_GENERATION_MODEL_STRATEGY),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    maxPromptLength: z.number(),
+    iconVariants: IconVariantsSchema,
+    supportsImageAttachment: z.boolean(),
+    maxAttachedImages: z.number(),
+    vendorId: z.string().uuid(),
+    pricingRules: ImageModelPricingRulesSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageGenerationModel = z.infer<typeof ImageGenerationModelSchema>;

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const ImageGenerationPresetSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    prompt: z.string(),
+    sample: z.string(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageGenerationPreset = z.infer<typeof ImageGenerationPresetSchema>;

package/image-generation/models/index.ts

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

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageGenerationJobSchema } from '../models';
+
+export namespace FindImageGenerationJobByIdQuery {
+    export const RequestSchema = z
+        .object({
+            uuid: z.string(),
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+        })
+        .refine((data) => data.userId || data.unregisteredUserId, {
+            message: 'Either userId or unregisteredUserId must be provided',
+        });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ImageGenerationJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ImageGenerationJobSchema } from '../models';
+
+export namespace FindImageGenerationJobsQuery {
+    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 Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(ImageGenerationJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

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

package/image-generation/queries/index.ts

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

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

@@ -0,0 +1,11 @@
+export const IMAGE_GENERATION_AMQP_ROUTES = {
+    EXECUTE: 'tools.image-generation.execute.rpc',
+    CONFIG: 'tools.image-generation.config.rpc',
+    FORWARD_JOB: 'tools.image-generation.jobs.forward.rpc',
+    GET_JOB: 'tools.image-generation.jobs.get.rpc',
+    LIST_JOBS: 'tools.image-generation.jobs.list.rpc',
+    SET_REACTION: 'tools.image-generation.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.image-generation.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.image-generation.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.image-generation.jobs.soft-delete-all.rpc',
+} as const;

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

@@ -0,0 +1,7 @@
+export const IMAGE_GENERATION_CONTROLLER = 'image-generation';
+
+export const IMAGE_GENERATION_ROUTES = {
+    KIE_MIDJOURNEY_CALLBACK: 'kie/midjourney/callback',
+    KIE_NANO_BANANA_CALLBACK: 'kie/nano-banana/callback',
+    KIE_FLUX_CALLBACK: 'kie/flux/callback',
+} as const;

package/image-generation/routes/index.ts

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

package/index.ts

@@ -7,9 +7,11 @@ export * from './language';
 export * from './video';
 export * from './writer';
 export * from './image-editor';
+export * from './image-generation';
 export * from './video-editor';
 export * from './music';
 export * from './ai-proxy';
+export * from './ai-vendor';
 
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -21,8 +23,10 @@ import * as language from './language';
 import * as video from './video';
 import * as writer from './writer';
 import * as imageEditor from './image-editor';
+import * as imageGeneration from './image-generation';
 import * as videoEditor from './video-editor';
 import * as music from './music';
+import * as aiVendor from './ai-vendor';
 
 export namespace ToolService {
     export import Common = common;
@@ -35,6 +39,8 @@ export namespace ToolService {
     export import Video = video;
     export import Writer = writer;
     export import ImageEditor = imageEditor;
+    export import ImageGeneration = imageGeneration;
     export import VideoEditor = videoEditor;
     export import Music = music;
+    export import AiVendor = aiVendor;
 }

package/music/commands/index.ts

@@ -6,3 +6,4 @@ export * from './generate-music.command';
 export * from './update-music-job-title.command';
 export * from './convert-to-wav.command';
 export * from './generate-lyrics.command';
+export * from './music-model';

package/music/commands/music-model/get-music-model-by-uuid.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { MusicModelSchema } from '../../models';
+import { ICommandResponseSchema } from '../../../common';
+
+export namespace GetMusicModelByUuidCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicModelSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/music-model/index.ts

@@ -0,0 +1 @@
+export * from './get-music-model-by-uuid.command';

package/music/commands/retry-music-job.command.ts

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

package/music/commands/set-reaction-to-music-job.command.ts

@@ -4,12 +4,25 @@ import { MusicJobSchema } from '../models/music-job.schema';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToMusicJobCommand {
-    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(MusicJobSchema);

package/music/models/music-job.schema.ts

@@ -35,6 +35,7 @@ export const MusicJobSchema = 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/music/models/music-track.schema.ts

@@ -6,6 +6,7 @@ export const MusicTrackSchema = z.object({
     audioId: z.string(),
     audioUrl: z.string(),
     coverUrl: z.string(),
+    prompt: z.string().nullable(),
     tags: z.string(),
     duration: z.number(),
 

package/music/routes/index.ts

@@ -1,2 +1,3 @@
 export * from './music.amqp.routes';
 export * from './music.http.routes';
+export * from './music-model.amqp.routes';

package/music/routes/music-model.amqp.routes.ts

@@ -0,0 +1,3 @@
+export const MUSIC_MODEL_AMQP_ROUTES = {
+    GET_MODEL_BY_UUID: 'tools.music.model.get-by-uuid.rpc',
+} as const;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.0.77-ai-proxy",
+  "version": "0.0.78-ai-proxy",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

package/paraphrase/commands/delete-all-paraphrase-jobs.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteAllParaphraseJobsCommand {
+    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/paraphrase/commands/delete-paraphrase-job-by-uuid.command.ts

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

@@ -1 +1,6 @@
 export * from './paraphrase.command';
+export * from './delete-paraphrase-job-by-uuid.command';
+export * from './delete-all-paraphrase-jobs.command';
+export * from './set-reaction-to-paraphrase-job.command';
+export * from './update-paraphrase-job-title.command';
+export * from './retry-paraphrase-job.command';

package/paraphrase/commands/retry-paraphrase-job.command.ts

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

package/paraphrase/commands/set-reaction-to-paraphrase-job.command.ts

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

package/paraphrase/commands/update-paraphrase-job-title.command.ts

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

package/paraphrase/models/paraphrase-job.schema.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
+import { PARAPHRASING_INTENSITY } from '../enums';
 
 export const ParaphraseJobSchema = z.object({
     uuid: z.string(),
@@ -10,8 +12,13 @@ export const ParaphraseJobSchema = z.object({
     aiTokenUsage: z.number().nullable(),
     price: z.number(),
     status: z.nativeEnum(JOB_STATUS),
+    title: z.string(),
+    error: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     typeId: z.string(),
     styleId: z.string(),
+    intensity: z.nativeEnum(PARAPHRASING_INTENSITY),
     createdAt: z.date(),
     updatedAt: z.date(),
     completedAt: z.date().nullable(),