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

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/constants/slide-layout-map.constant.ts

@@ -11,4 +11,5 @@ export const SLIDE_LAYOUT_MAP = new Map<SLIDE_CONTENT_TYPE, SLIDE_LAYOUT[]>([
     [SLIDE_CONTENT_TYPE.THANK_YOU, [SLIDE_LAYOUT.TYPE_1]],
     [SLIDE_CONTENT_TYPE.TABLE, [SLIDE_LAYOUT.TYPE_1]],
     [SLIDE_CONTENT_TYPE.CHART, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.TIMELINE, [SLIDE_LAYOUT.TYPE_1]],
 ]);

package/presentation/enums/slide-content-type.enum.ts

@@ -8,4 +8,5 @@ export enum SLIDE_CONTENT_TYPE {
     THANK_YOU = 'THANK_YOU',
     TABLE = 'TABLE',
     CHART = 'CHART',
+    TIMELINE = 'TIMELINE',
 }

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-edit.schema.ts

@@ -13,6 +13,7 @@ import {
     IBarChartSlideDataStructure,
     IChartSlideDataStructure,
     ImageSlotSchema,
+    ITimelineSlideDataStructure,
 } from './slide-content.schema';
 
 export const CoverSlideDataUserEditSchema = z.object({
@@ -146,6 +147,25 @@ export const ChartSlideDataUserEditSchema = z.object({
     version: z.literal(1),
 }) satisfies z.ZodType<IChartSlideDataStructure>;
 
+export const TimelineSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TIMELINE),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(1000),
+    timeline: z.object({
+        events: z
+            .array(
+                z.object({
+                    date: z.string().min(1).max(100),
+                    title: z.string().min(1).max(200),
+                    description: z.string().min(1).max(500),
+                }),
+            )
+            .min(2)
+            .max(10),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITimelineSlideDataStructure>;
+
 export const SlideContentUserEditSchema = z.discriminatedUnion('contentType', [
     CoverSlideDataUserEditSchema,
     StructuredListSlideDataUserEditSchema,
@@ -156,5 +176,6 @@ export const SlideContentUserEditSchema = z.discriminatedUnion('contentType', [
     ThankYouSlideDataUserEditSchema,
     TableSlideDataUserEditSchema,
     ChartSlideDataUserEditSchema,
+    TimelineSlideDataUserEditSchema,
 ]);
 export type SlideContentUserEdit = z.infer<typeof SlideContentUserEditSchema>;

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

@@ -108,6 +108,20 @@ export interface IChartSlideDataStructure {
     version: 1;
 }
 
+export interface ITimelineSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.TIMELINE;
+    title: string;
+    description: string;
+    timeline: {
+        events: Array<{
+            date: string;
+            title: string;
+            description: string;
+        }>;
+    };
+    version: 1;
+}
+
 export const CoverSlideDataSchema = z.object({
     contentType: z.literal(SLIDE_CONTENT_TYPE.COVER),
     title: z.string().describe('Slide title in about 6 words').min(10).max(150),
@@ -313,6 +327,42 @@ export const ChartSlideDataSchema = z.object({
 }) satisfies z.ZodType<IChartSlideDataStructure>;
 export type ChartSlideData = z.infer<typeof ChartSlideDataSchema>;
 
+export const TimelineSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TIMELINE),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(150),
+    description: z.string().describe('Brief context for the timeline').min(10).max(200),
+    timeline: z.object({
+        events: z
+            .array(
+                z.object({
+                    date: z
+                        .string()
+                        .describe(
+                            'Date or time period label. MUST be general/approximate if exact date unknown (e.g., "Early 2020s", "Mid-1990s", "Recent years")',
+                        )
+                        .min(2)
+                        .max(50),
+                    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')
+                        .min(20)
+                        .max(150),
+                }),
+            )
+            .length(4)
+            .describe('Timeline must contain exactly 4 chronological events'),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITimelineSlideDataStructure>;
+export type TimelineSlideData = z.infer<typeof TimelineSlideDataSchema>;
+
 export const SlideContentSchema = z.discriminatedUnion('contentType', [
     CoverSlideDataSchema,
     StructuredListSlideDataSchema,
@@ -323,5 +373,6 @@ export const SlideContentSchema = z.discriminatedUnion('contentType', [
     ThankYouSlideDataSchema,
     TableSlideDataSchema,
     ChartSlideDataSchema,
+    TimelineSlideDataSchema,
 ]);
 export type SlideContent = z.infer<typeof SlideContentSchema>;

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/tool.schema.ts

@@ -6,6 +6,9 @@ export const ToolSchema = z.object({
     title: z.string(),
     description: z.string(),
     icon: z.string(),
+    alias: z.string(),
+    bgColor: z.string(),
+    iconColor: z.string(),
     order: z.number(),
     contentType: z.nativeEnum(TOOL_CONTENT_TYPE),
     createdAt: z.date(),

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/enums/video-pricing-rule-type.enum.ts

@@ -1,3 +1,4 @@
 export enum VIDEO_PRICING_RULE_TYPE {
     FLAT = 'flat',
+    PER_SECOND = 'per_second',
 }

package/video/enums/video-strategy.enum.ts

@@ -5,4 +5,5 @@ export enum VIDEO_GENERATION_STRATEGY {
     RUNWAY_CALLBACK = 'RUNWAY_CALLBACK',
     SORA_2_VIDEO_GENERATION_POLLING = 'SORA_2_VIDEO_GENERATION_POLLING',
     SORA_2_VIDEO_GENERATION_CALLBACK = 'SORA_2_VIDEO_GENERATION_CALLBACK',
+    SEEDANCE_VIDEO_GENERATION_CALLBACK = 'SEEDANCE_VIDEO_GENERATION_CALLBACK',
 }

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

@@ -20,20 +20,28 @@ export const VideoModelParamsSchema = z.object({
         })
         .optional(),
     quality: z.string().optional(),
+    resolution: z
+        .object({
+            options: z.array(z.string()),
+        })
+        .optional(),
 });
 
 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(),
+    resolution: z.string().optional(),
 });
 export type VideoGenerationRequestParams = z.infer<typeof VideoGenerationRequestParamsSchema>;
 
 export const VideoModelPricingRuleConditionSchema = z.object({
-    aspectRatio: z.string(),
+    aspectRatio: z.string().optional(),
+    resolution: z.string().optional(),
 });
 export type VideoModelPricingRuleCondition = z.infer<typeof VideoModelPricingRuleConditionSchema>;
 

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/routes/video.http.routes.ts

@@ -4,4 +4,5 @@ export const VIDEO_GENERATION_ROUTES = {
     KIE_VEO_CALLBACK: 'kie/veo/callback',
     KIE_RUNWAY_CALLBACK: 'kie/runway/callback',
     KIE_SORA_2_CALLBACK: 'kie/sora-2/callback',
+    KIE_SEEDANCE_CALLBACK: 'kie/seedance/callback',
 };

package/video/utils/calculate-video-generation-price.util.ts

@@ -36,7 +36,13 @@ export function calculateVideoGenerationPrice({
     params: VideoGenerationRequestParams;
     rules: VideoModelPricingRules;
 }) {
-    const base = pricePerSecond * params.duration;
+    const perSecondRule = rules
+        .filter((r) => r.type === VIDEO_PRICING_RULE_TYPE.PER_SECOND)
+        .find((r) => matchesCondition(r.condition, params));
+
+    const effectivePricePerSecond = perSecondRule ? perSecondRule.value : pricePerSecond;
+
+    const base = effectivePricePerSecond * params.duration;
 
     const flatMarkup = rules.reduce((sum, r) => {
         if (r.type !== VIDEO_PRICING_RULE_TYPE.FLAT) {

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