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

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/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/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-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/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/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/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(),