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

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,8 +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';
@@ -20,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;
@@ -34,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/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/music.http.routes.ts

@@ -1,5 +1 @@
 export const MUSIC_CONTROLLER = 'music';
-
-export const MUSIC_ROUTES = {
-    KIE_SUNO_CALLBACK: '/kie/suno/callback',
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.0.78",
+  "version": "0.0.79-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(),

package/paraphrase/queries/find-paraphrase-jobs.query.ts

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

package/paraphrase/queries/index.ts

@@ -1,2 +1,3 @@
 export * from './find-paraphrase-job-by-uuid.query';
 export * from './get-paraphrase-tool-config.query';
+export * from './find-paraphrase-jobs.query';

package/paraphrase/routes/paraphrase.amqp.routes.ts

@@ -2,4 +2,10 @@ export const PARAPHRASE_AMQP_ROUTES = {
     EXECUTE: 'tools.paraphrase.execute.rpc',
     CONFIG: 'tools.paraphrase.config.rpc',
     GET_JOB: 'tools.paraphrase.jobs.get.rpc',
+    LIST_JOBS: 'tools.paraphrase.jobs.list.rpc',
+    SET_REACTION: 'tools.paraphrase.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.paraphrase.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.paraphrase.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.paraphrase.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.paraphrase.jobs.retry.rpc',
 } as const;

package/presentation/commands/index.ts

@@ -16,3 +16,4 @@ export * from './update-slide-image-slot.command';
 export * from './update-slide.command';
 export * from './presentation-paraphrase.command';
 export * from './presentation-generate-report.command';
+export * from './set-reaction-to-presentation.command';

package/presentation/commands/set-reaction-to-presentation.command.ts

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

package/presentation/models/pptx-export-payload.ts

@@ -5,6 +5,7 @@ export enum PPTX_SHAPE_TYPE {
     PICTURE_BOX = 'picture_box',
     CUSTOM_SHAPE = 'custom_shape',
     TABLE = 'table',
+    CHEVRON = 'chevron',
 }
 
 export enum PPTX_H_ALIGN {
@@ -47,6 +48,13 @@ export enum PPTX_CUSTOM_SHAPE_TYPE {
     ROUND_RECT = 'roundRect',
 }
 
+export enum PPTX_CHEVRON_DIRECTION {
+    RIGHT = 'right',
+    LEFT = 'left',
+    UP = 'up',
+    DOWN = 'down',
+}
+
 export const PPTXShadowSchema = z.object({
     type: z.nativeEnum(PPTX_SHADOW_TYPE),
     opacity: z.number().min(0).max(100).optional().describe('percents, range 0-100'),
@@ -182,6 +190,17 @@ export const PPTXTableShapeSchema = z.object({
 });
 export type PPTXTableShape = z.infer<typeof PPTXTableShapeSchema>;
 
+// Chevron
+export const PPTXChevronShapeSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.CHEVRON),
+    direction: z.nativeEnum(PPTX_CHEVRON_DIRECTION).default(PPTX_CHEVRON_DIRECTION.RIGHT),
+    position: PPTXPositionSchema,
+    fill: PPTXFillSchema.optional(),
+    align: z.nativeEnum(PPTX_H_ALIGN).optional().default(PPTX_H_ALIGN.CENTER),
+    valign: z.nativeEnum(PPTX_V_ALIGN).optional().default(PPTX_V_ALIGN.MIDDLE),
+});
+export type PPTXChevronShape = z.infer<typeof PPTXChevronShapeSchema>;
+
 // Overview
 
 export const PPTXShapeSchema = z.discriminatedUnion('type', [
@@ -189,6 +208,7 @@ export const PPTXShapeSchema = z.discriminatedUnion('type', [
     PPTXPictureBoxSchema,
     PPTXCustomShapeSchema,
     PPTXTableShapeSchema,
+    PPTXChevronShapeSchema,
 ]);
 export type PPTXShape = z.infer<typeof PPTXShapeSchema>;
 

package/presentation/models/presentation.schema.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { PRESENTATION_STAGE } from '../enums';
 import { SlideOutlineSchema } from './slide-outline.schema';
 import { SlideSchema } from './slide.schema';
+import { USER_REACTION } from '../../common';
 
 export const PresentationSchema = z.object({
     uuid: z.string().uuid(),
@@ -12,6 +13,8 @@ export const PresentationSchema = z.object({
     languageId: z.string(),
     templateId: z.string(),
     downloadUrl: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     userId: z.string().uuid().nullable().optional(),
     unregisteredUserId: z.string().uuid().nullable().optional(),
     slideCount: z.number(),

package/presentation/models/slide-content.schema.ts

@@ -342,7 +342,13 @@ export const TimelineSlideDataSchema = z.object({
                         )
                         .min(2)
                         .max(50),
-                    title: z.string().describe('Event title in 2-4 words').min(5).max(80),
+                    title: z
+                        .string()
+                        .describe(
+                            'Event title. Prefer 2 words, max 3 words. Keep it short and punchy.',
+                        )
+                        .min(5)
+                        .max(60),
                     description: z
                         .string()
                         .describe('Brief description of the event or milestone')
@@ -350,8 +356,8 @@ export const TimelineSlideDataSchema = z.object({
                         .max(150),
                 }),
             )
-            .length(5)
-            .describe('Timeline must contain exactly 5 chronological events'),
+            .length(4)
+            .describe('Timeline must contain exactly 4 chronological events'),
     }),
     version: z.literal(1),
 }) satisfies z.ZodType<ITimelineSlideDataStructure>;

package/presentation/routes/presentation.routes.ts

@@ -18,6 +18,7 @@ export const PRESENTATION_AMQP_ROUTES = {
     UPDATE_SLIDE: 'tools.presentation.update-slide.rpc',
     PARAPHRASE: 'tools.presentation.actions.paraphrase.rpc',
     GENERATE_REPORT: 'tools.presentation.actions.generate-report.rpc',
+    SET_REACTION: 'tools.presentation.set-reaction.rpc',
 } as const;
 
 export const PRESENTATION_SLIDE_OUTLINE_AMQP_ROUTES = {

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

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