@purpleschool/gptbot 0.14.24-stage2 → 0.14.25

package/constants/file/file.constants.ts

@@ -18,6 +18,12 @@ export const SUPPORTED_FILES = new Map<
     ['image/webp', { type: FILE_TYPE.IMAGE, size: MAX_IMAGE_UPLOAD_SIZE }],
     ['audio/mp3', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
     ['audio/mpeg', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
+    ['audio/webm', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
+    ['audio/webm;codecs=opus', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
+    ['video/webm', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
+    ['audio/mp4', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
+    ['audio/ogg', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
+    ['audio/ogg;codecs=opus', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
     ['audio/wave', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
     ['audio/wav', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],
     ['audio/x-wav', { type: FILE_TYPE.AUDIO, size: MAX_AUDIO_UPLOAD_SIZE }],

package/models/avatar-studio/avatar-studio.schema.ts

@@ -45,13 +45,14 @@ export type AvatarStudioWordTiming = z.infer<typeof AvatarStudioWordTimingSchema
 
 export const AvatarStudioMediaSchema = z.object({
     uuid: z.string().uuid(),
-    userId: z.string().uuid(),
+    userId: z.string().uuid().nullable(),
     clipId: z.string().uuid().nullable(),
     sceneId: z.string().uuid().nullable(),
     fileId: z.string().uuid(),
     kind: z.nativeEnum(AVATAR_STUDIO_MEDIA_KIND),
     source: z.nativeEnum(AVATAR_STUDIO_MEDIA_SOURCE),
     role: z.nativeEnum(AVATAR_STUDIO_MEDIA_ROLE),
+    title: z.string().nullable(),
     prompt: z.string().nullable(),
     toolJobId: z.string().uuid().nullable(),
     durationSeconds: z.number().nullable(),
@@ -72,10 +73,32 @@ export const AvatarStudioSceneReferenceMediaSchema = z.object({
 });
 export type AvatarStudioSceneReferenceMedia = z.infer<typeof AvatarStudioSceneReferenceMediaSchema>;
 
-export const AvatarStudioSceneVoiceConfigSchema = z.object({
+export const AvatarStudioTrimConfigFields = {
+    trimStart: z.number().nonnegative().nullable().default(null),
+    trimEnd: z.number().nonnegative().nullable().default(null),
+};
+
+export const validateAvatarStudioTrim = (
+    { trimStart, trimEnd }: { trimStart?: number | null; trimEnd?: number | null },
+    ctx: z.RefinementCtx,
+): void => {
+    if (trimStart != null && trimEnd != null && trimEnd <= trimStart) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'trimEnd must be greater than trimStart',
+            path: ['trimEnd'],
+        });
+    }
+};
+
+export const AvatarStudioSceneVoiceConfigBaseSchema = z.object({
     text: z.string().default(''),
     mediaId: z.string().uuid().nullable().default(null),
+    ...AvatarStudioTrimConfigFields,
 });
+
+export const AvatarStudioSceneVoiceConfigSchema =
+    AvatarStudioSceneVoiceConfigBaseSchema.superRefine(validateAvatarStudioTrim);
 export type AvatarStudioSceneVoiceConfig = z.infer<typeof AvatarStudioSceneVoiceConfigSchema>;
 
 export const AvatarStudioSceneImageConfigSchema = z.object({
@@ -84,13 +107,17 @@ export const AvatarStudioSceneImageConfigSchema = z.object({
 });
 export type AvatarStudioSceneImageConfig = z.infer<typeof AvatarStudioSceneImageConfigSchema>;
 
-export const AvatarStudioSceneVideoConfigSchema = z.object({
+export const AvatarStudioSceneVideoConfigBaseSchema = z.object({
     prompt: z.string().nullable().default(null),
     durationSeconds: z.number().positive().default(5),
     videoMode: z.nativeEnum(AVATAR_STUDIO_VIDEO_MODE).default(AVATAR_STUDIO_VIDEO_MODE.B_ROLL),
     quality: z.nativeEnum(AVATAR_STUDIO_VIDEO_QUALITY).default(AVATAR_STUDIO_VIDEO_QUALITY.P720),
     sound: z.boolean().default(false),
+    ...AvatarStudioTrimConfigFields,
 });
+
+export const AvatarStudioSceneVideoConfigSchema =
+    AvatarStudioSceneVideoConfigBaseSchema.superRefine(validateAvatarStudioTrim);
 export type AvatarStudioSceneVideoConfig = z.infer<typeof AvatarStudioSceneVideoConfigSchema>;
 
 export const AvatarStudioSceneGenerationJobSchema = z.object({
@@ -141,10 +168,13 @@ export type AvatarStudioScene = z.infer<typeof AvatarStudioSceneSchema>;
 
 export const AvatarStudioVoiceSchema = z.object({
     uuid: z.string().uuid(),
-    userId: z.string().uuid(),
+    userId: z.string().uuid().nullable(),
     clipId: z.string().uuid().nullable(),
     title: z.string(),
     source: z.nativeEnum(AVATAR_STUDIO_VOICE_SOURCE),
+    presetKey: z.string().nullable(),
+    gender: z.enum(['male', 'female']).nullable(),
+    sortOrder: z.number().int().nullable(),
     sampleMediaId: z.string().uuid().nullable(),
     sampleText: z.string().nullable(),
     metadata: JsonObjectSchema.nullable(),

package/models/tools/image-recognition/image-recognition-category.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+export const ImageRecognitionCategorySchema = z.object({
+    uuid: z.string(),
+    parentId: z.string().nullable(),
+    title: z.string(),
+    systemPrompt: z.string(),
+    order: z.number(),
+    status: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageRecognitionCategory = z.infer<typeof ImageRecognitionCategorySchema>;

package/models/tools/image-recognition/image-recognition-config.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ImageRecognitionModelSchema } from './image-recognition-model.schema';
+import { ImageRecognitionCategorySchema } from './image-recognition-category.schema';
+
+export const ImageRecognitionConfigSchema = z.object({
+    models: z.array(ImageRecognitionModelSchema),
+    categories: z.array(ImageRecognitionCategorySchema),
+});
+
+export type ImageRecognitionConfig = z.infer<typeof ImageRecognitionConfigSchema>;

package/models/tools/image-recognition/image-recognition-job.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../../constants';
+import { ToolJobSchema } from '../../tool-job.schema';
+import { AttachedToolFileSchema } from '../common';
+
+export const ImageRecognitionJobParamsSchema = z.object({
+    attachedFiles: z.array(AttachedToolFileSchema),
+});
+
+export type ImageRecognitionJobParams = z.infer<typeof ImageRecognitionJobParamsSchema>;
+
+export const ImageRecognitionJobSchema = ToolJobSchema.extend({
+    title: z.string(),
+    prompt: z.string().nullable(),
+    categoryId: z.string(),
+    aiOutput: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
+    modelId: z.string(),
+    price: z.number(),
+    params: ImageRecognitionJobParamsSchema,
+    completedAt: z.date().nullable().optional(),
+});
+
+export type ImageRecognitionJob = z.infer<typeof ImageRecognitionJobSchema>;

package/models/tools/image-recognition/image-recognition-model.schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { IconVariantsSchema } from '../../icon-variants.schema';
+
+export const ImageRecognitionModelParamsSchema = z.object({
+    imageAttachment: z.object({
+        supported: z.boolean(),
+        maxImages: z.number(),
+        acceptedTypes: z.array(z.string()),
+    }),
+});
+
+export type ImageRecognitionModelParams = z.infer<typeof ImageRecognitionModelParamsSchema>;
+
+export const ImageRecognitionModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    price: z.number(),
+    order: z.number(),
+    status: z.string(),
+    icons: IconVariantsSchema,
+    params: ImageRecognitionModelParamsSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type ImageRecognitionModel = z.infer<typeof ImageRecognitionModelSchema>;

package/models/tools/image-recognition/index.ts

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

package/models/tools/index.ts

@@ -7,6 +7,7 @@ export * from './tts';
 export * from './video';
 export * from './writer';
 export * from './image-editor';
+export * from './image-recognition';
 export * from './video-editor';
 export * from './music';
 export * from './image-generation';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.14.24-stage2",
+  "version": "0.14.25",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",