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

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

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

@@ -12,7 +12,9 @@ export const STTJobSchema = z.object({
     fileUrl: z.string(),
     aiResponse: STTResponseSchema.nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     status: z.nativeEnum(JOB_STATUS),
+    duration: z.number(),
     error: z.string().nullable(),
     userId: z.string().nullable(),
     unregisteredUserId: z.string().nullable(),

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

@@ -1,5 +1,6 @@
 export enum TOOL_CONTENT_TYPE {
     IMAGE_EDITOR = 'IMAGE_EDITOR',
+    IMAGE_GENERATION = 'IMAGE_GENERATION',
     TEXT_TO_SPEECH = 'TEXT_TO_SPEECH',
     SPEECH_TO_TEXT = 'SPEECH_TO_TEXT',
     REPHRASE = 'REPHRASE',

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

@@ -11,4 +11,5 @@ export enum TOOL_TYPE {
     VIDEO_EDITOR = 'VIDEO_EDITOR',
     MUSIC = 'MUSIC',
     MUSIC_ACTION = 'MUSIC_ACTION',
+    IMAGE_GENERATION = 'IMAGE_GENERATION',
 }

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

@@ -4,6 +4,7 @@ import { VideoConfigSchema } from '../../video';
 import { MusicConfigSchema } from '../../music';
 import { WriterConfigSchema } from '../../writer';
 import { ImageEditorConfigSchema } from '../../image-editor';
+import { ImageGenerationConfigSchema } from '../../image-generation';
 import { ParaphraseToolConfigSchema } from '../../paraphrase';
 import { PresentationConfigSchema } from '../../presentation';
 import { VideoEditorConfigSchema } from '../../video-editor';
@@ -15,6 +16,7 @@ export const GlobalToolsConfigSchema = z.object({
     [TOOL_CONTENT_TYPE.MUSIC]: MusicConfigSchema,
     [TOOL_CONTENT_TYPE.WRITER]: WriterConfigSchema,
     [TOOL_CONTENT_TYPE.IMAGE_EDITOR]: ImageEditorConfigSchema,
+    [TOOL_CONTENT_TYPE.IMAGE_GENERATION]: ImageGenerationConfigSchema,
     [TOOL_CONTENT_TYPE.REPHRASE]: ParaphraseToolConfigSchema,
     [TOOL_CONTENT_TYPE.PRESENTATION]: PresentationConfigSchema,
     [TOOL_CONTENT_TYPE.VIDEO_EDITOR]: VideoEditorConfigSchema,

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

@@ -4,6 +4,7 @@ import { VideoConfigSchema } from '../../video';
 import { MusicConfigSchema } from '../../music';
 import { WriterConfigSchema } from '../../writer';
 import { ImageEditorConfigSchema } from '../../image-editor';
+import { ImageGenerationConfigSchema } from '../../image-generation';
 import { ParaphraseToolConfigSchema } from '../../paraphrase';
 import { PresentationConfigSchema } from '../../presentation';
 import { VideoEditorConfigSchema } from '../../video-editor';
@@ -37,6 +38,12 @@ export const ToolWithConfigSchema = z.discriminatedUnion('contentType', [
             config: ImageEditorConfigSchema,
         }),
     ),
+    ToolSchema.merge(
+        z.object({
+            contentType: z.literal(TOOL_CONTENT_TYPE.IMAGE_GENERATION),
+            config: ImageGenerationConfigSchema,
+        }),
+    ),
     ToolSchema.merge(
         z.object({
             contentType: z.literal(TOOL_CONTENT_TYPE.REPHRASE),

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

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

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

@@ -15,12 +15,14 @@ export const TTSJobSchema = z.object({
     userInput: z.string(),
     aiResponse: z.string().nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     title: z.string(),
     status: z.nativeEnum(JOB_STATUS),
     error: z.string().nullable(),
     modelId: z.string(),
     voiceId: z.string(),
     price: z.number(),
+    duration: z.number(),
     userId: z.string().nullable(),
     unregisteredUserId: z.string().nullable(),
     isDeleted: z.boolean(),

package/video/commands/index.ts

@@ -4,3 +4,4 @@ export * from './retry-video-job.command';
 export * from './set-reaction-to-video-job.command';
 export * from './video.command';
 export * from './update-video-job-title.command';
+export * from './video-model';

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

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

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

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

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

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

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

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

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

@@ -4,8 +4,10 @@ import { USER_REACTION } from '../../common';
 
 export const VideoJobParamsSchema = z.object({
     imageUrls: z.string().array().optional(),
+    imageIds: z.array(z.string()).optional(),
     duration: z.number().optional(),
     aspectRatio: z.string().optional(),
+    resolution: z.string().optional(),
 });
 
 export type VideoJobParams = z.infer<typeof VideoJobParamsSchema>;
@@ -14,6 +16,7 @@ export const VideoJobSchema = 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/video/models/video-model.schema.ts

@@ -31,6 +31,7 @@ export type VideoModelParams = z.infer<typeof VideoModelParamsSchema>;
 
 export const VideoGenerationRequestParamsSchema = z.object({
     imageUrls: z.string().array().optional(),
+    imageIds: z.array(z.string()).optional(),
     duration: z.number(),
     aspectRatio: z.string().optional(),
     quality: z.string().optional(),

package/video/routes/index.ts

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

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

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

package/video-editor/commands/edit-video.command.ts

@@ -7,10 +7,11 @@ export namespace EditVideoCommand {
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
         prompt: z.string(),
+        inputVideoId: z.string().uuid(),
         inputVideoUrl: z.string(),
         duration: z.number(),
         userBalance: z.number(),
-        modelId: z.string(),
+        modelId: z.string().uuid(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/video-editor/commands/index.ts

@@ -4,3 +4,4 @@ export * from './retry-video-editor-job.command';
 export * from './set-reaction-to-video-editor-job.command';
 export * from './update-video-editor-job-title.command';
 export * from './edit-video.command';
+export * from './video-editor-model';

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

@@ -8,6 +8,11 @@ export namespace RetryVideoEditorJobCommand {
         userBalance: z.number(),
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        prompt: z.string().optional(),
+        inputVideoId: z.string().uuid().optional(),
+        inputVideoUrl: z.string().optional(),
+        duration: z.number().optional(),
+        modelId: z.string().uuid().optional(),
     });
     export type Request = z.infer<typeof RequestSchema>;
 

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

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

package/video-editor/commands/video-editor-model/get-video-editor-model.command.ts

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

package/video-editor/commands/video-editor-model/index.ts

@@ -0,0 +1 @@
+export * from './get-video-editor-model.command';

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

@@ -10,10 +10,13 @@ export const VideoEditorJobSchema = z.object({
     error: z.string().nullable(),
     price: z.number(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     modelId: z.string(),
     inputVideoUrl: z.string(),
+    inputVideoId: z.string().nullable(),
     outputVideoUrl: z.string().nullable(),
+    outputVideoId: z.string().nullable(),
     duration: z.number(),
     attempts: z.array(z.any()),
     userId: z.string().nullable().optional(),

package/video-editor/routes/index.ts

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

package/video-editor/routes/video-editor-model.amqp.routes.ts

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

package/writer/commands/set-reaction-writer-document.command.ts

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

package/writer/models/writer-document.schema.ts

@@ -16,6 +16,7 @@ export const WriterDocumentSchema = z.object({
     unregisteredUserId: z.string().nullable(),
     modelId: z.string().nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     pages: z.number(),
     isDeleted: z.boolean(),
     createdAt: z.date(),