@purpleschool/gptbot 0.14.11 → 0.14.13-avatar-studio

package/constants/avatar-studio/enums/avatar-studio-voice-source.enum.ts

@@ -0,0 +1,5 @@
+export enum AVATAR_STUDIO_VOICE_SOURCE {
+    UPLOAD = 'upload',
+    TTS = 'tts',
+    VOICE_DESIGN = 'voice_design',
+}

package/constants/avatar-studio/enums/index.ts

@@ -0,0 +1,16 @@
+export * from './avatar-studio-export-status.enum';
+export * from './avatar-studio-image-style.enum';
+export * from './avatar-studio-job-phase.enum';
+export * from './avatar-studio-job-status.enum';
+export * from './avatar-studio-job-type.enum';
+export * from './avatar-studio-media-kind.enum';
+export * from './avatar-studio-media-role.enum';
+export * from './avatar-studio-media-source.enum';
+export * from './avatar-studio-scene-kind.enum';
+export * from './avatar-studio-scriptwriter-role.enum';
+export * from './avatar-studio-slot.enum';
+export * from './avatar-studio-subtitle-font.enum';
+export * from './avatar-studio-subtitle-mode.enum';
+export * from './avatar-studio-video-mode.enum';
+export * from './avatar-studio-video-quality.enum';
+export * from './avatar-studio-voice-source.enum';

package/constants/avatar-studio/index.ts

@@ -0,0 +1 @@
+export * from './enums';

package/constants/canvas-node/enums/canvas-node-error-kind.enum.ts

@@ -0,0 +1,4 @@
+export enum CANVAS_NODE_ERROR_KIND {
+    RUNTIME_VALIDATION = 'RUNTIME_VALIDATION',
+    EXECUTION_ERROR = 'EXECUTION_ERROR',
+}

package/constants/canvas-node/enums/index.ts

@@ -1,2 +1,3 @@
+export * from './canvas-node-error-kind.enum';
 export * from './canvas-node-type.enum';
 export * from './node-run-status.enum';

package/constants/index.ts

@@ -1,6 +1,7 @@
 export * from './ai-model';
 export * from './b2b';
 export * from './api-key';
+export * from './avatar-studio';
 export * from './agents';
 export * from './blog';
 export * from './billing';

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

@@ -0,0 +1,221 @@
+import { z } from 'zod';
+import {
+    AVATAR_STUDIO_EXPORT_STATUS,
+    AVATAR_STUDIO_IMAGE_STYLE,
+    AVATAR_STUDIO_JOB_PHASE,
+    AVATAR_STUDIO_JOB_STATUS,
+    AVATAR_STUDIO_JOB_TYPE,
+    AVATAR_STUDIO_MEDIA_KIND,
+    AVATAR_STUDIO_MEDIA_ROLE,
+    AVATAR_STUDIO_MEDIA_SOURCE,
+    AVATAR_STUDIO_SCRIPTWRITER_ROLE,
+    AVATAR_STUDIO_SLOT,
+    AVATAR_STUDIO_SUBTITLE_FONT,
+    AVATAR_STUDIO_SUBTITLE_MODE,
+    AVATAR_STUDIO_VIDEO_MODE,
+    AVATAR_STUDIO_VIDEO_QUALITY,
+    AVATAR_STUDIO_VOICE_SOURCE,
+} from '../../constants';
+import { FileSchema } from '../file.schema';
+import { JsonObjectSchema, JsonValueSchema } from '../json-value.schema';
+
+export const AvatarStudioAspectRatioSchema = z.enum(['9:16', '16:9', '1:1', '4:5']);
+export type AvatarStudioAspectRatio = z.infer<typeof AvatarStudioAspectRatioSchema>;
+
+const AvatarStudioSubtitleColorSchema = z.string().regex(/^#[0-9A-Fa-f]{6}$/);
+
+export const AvatarStudioSubtitleSettingsSchema = z
+    .object({
+        mode: z.nativeEnum(AVATAR_STUDIO_SUBTITLE_MODE).default(AVATAR_STUDIO_SUBTITLE_MODE.NONE),
+        font: z
+            .nativeEnum(AVATAR_STUDIO_SUBTITLE_FONT)
+            .default(AVATAR_STUDIO_SUBTITLE_FONT.ROBOTO_REGULAR),
+        textColor: AvatarStudioSubtitleColorSchema.default('#FFFFFF'),
+        backgroundColor: AvatarStudioSubtitleColorSchema.default('#000000'),
+    })
+    .strict();
+export type AvatarStudioSubtitleSettings = z.infer<typeof AvatarStudioSubtitleSettingsSchema>;
+
+export const AvatarStudioWordTimingSchema = z.object({
+    word: z.string(),
+    start: z.number().min(0),
+    end: z.number().min(0),
+});
+export type AvatarStudioWordTiming = z.infer<typeof AvatarStudioWordTimingSchema>;
+
+export const AvatarStudioMediaSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    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),
+    prompt: z.string().nullable(),
+    toolJobId: z.string().uuid().nullable(),
+    durationSeconds: z.number().nullable(),
+    transcript: z.string().nullable(),
+    file: FileSchema.optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type AvatarStudioMedia = z.infer<typeof AvatarStudioMediaSchema>;
+
+export const AvatarStudioSceneReferenceMediaSchema = z.object({
+    uuid: z.string().uuid(),
+    sceneId: z.string().uuid(),
+    mediaId: z.string().uuid(),
+    position: z.number().int().min(0),
+    media: AvatarStudioMediaSchema.optional(),
+    createdAt: z.date(),
+});
+export type AvatarStudioSceneReferenceMedia = z.infer<typeof AvatarStudioSceneReferenceMediaSchema>;
+
+export const AvatarStudioSceneVoiceConfigSchema = z.object({
+    text: z.string().default(''),
+    mediaId: z.string().uuid().nullable().default(null),
+});
+export type AvatarStudioSceneVoiceConfig = z.infer<typeof AvatarStudioSceneVoiceConfigSchema>;
+
+export const AvatarStudioSceneImageConfigSchema = z.object({
+    prompt: z.string().nullable().default(null),
+    style: z.nativeEnum(AVATAR_STUDIO_IMAGE_STYLE).default(AVATAR_STUDIO_IMAGE_STYLE.UGC),
+});
+export type AvatarStudioSceneImageConfig = z.infer<typeof AvatarStudioSceneImageConfigSchema>;
+
+export const AvatarStudioSceneVideoConfigSchema = 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),
+});
+export type AvatarStudioSceneVideoConfig = z.infer<typeof AvatarStudioSceneVideoConfigSchema>;
+
+export const AvatarStudioSceneSchema = z.object({
+    uuid: z.string().uuid(),
+    clipId: z.string().uuid(),
+    position: z.number().int().min(0),
+    voiceConfig: AvatarStudioSceneVoiceConfigSchema,
+    imageConfig: AvatarStudioSceneImageConfigSchema,
+    videoConfig: AvatarStudioSceneVideoConfigSchema,
+    frameMediaId: z.string().uuid().nullable(),
+    sceneVideoMediaId: z.string().uuid().nullable(),
+    voiceMediaId: z.string().uuid().nullable(),
+    avatarVideoMediaId: z.string().uuid().nullable(),
+    frameStatus: z.nativeEnum(AVATAR_STUDIO_JOB_STATUS),
+    videoStatus: z.nativeEnum(AVATAR_STUDIO_JOB_STATUS),
+    voiceStatus: z.nativeEnum(AVATAR_STUDIO_JOB_STATUS),
+    avatarStatus: z.nativeEnum(AVATAR_STUDIO_JOB_STATUS),
+    frameError: z.string().nullable(),
+    videoError: z.string().nullable(),
+    voiceError: z.string().nullable(),
+    avatarError: z.string().nullable(),
+    wordTimings: z.array(AvatarStudioWordTimingSchema).nullable(),
+    transcript: z.string().nullable(),
+    subtitles: JsonValueSchema.nullable(),
+    frameMedia: AvatarStudioMediaSchema.nullable().optional(),
+    sceneVideoMedia: AvatarStudioMediaSchema.nullable().optional(),
+    voiceMedia: AvatarStudioMediaSchema.nullable().optional(),
+    avatarVideoMedia: AvatarStudioMediaSchema.nullable().optional(),
+    referenceMedia: z.array(AvatarStudioSceneReferenceMediaSchema).optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type AvatarStudioScene = z.infer<typeof AvatarStudioSceneSchema>;
+
+export const AvatarStudioVoiceSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    clipId: z.string().uuid().nullable(),
+    title: z.string(),
+    source: z.nativeEnum(AVATAR_STUDIO_VOICE_SOURCE),
+    sampleMediaId: z.string().uuid().nullable(),
+    sampleText: z.string().nullable(),
+    metadata: JsonObjectSchema.nullable(),
+    sampleMedia: AvatarStudioMediaSchema.nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    deletedAt: z.date().nullable(),
+});
+export type AvatarStudioVoice = z.infer<typeof AvatarStudioVoiceSchema>;
+
+export const AvatarStudioGenerationJobBaseSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    clipId: z.string().uuid().nullable(),
+    sceneId: z.string().uuid().nullable(),
+    parentJobId: z.string().uuid().nullable(),
+    toolJobId: z.string().uuid().nullable(),
+    type: z.nativeEnum(AVATAR_STUDIO_JOB_TYPE),
+    phase: z.nativeEnum(AVATAR_STUDIO_JOB_PHASE).nullable(),
+    targetSlot: z.nativeEnum(AVATAR_STUDIO_SLOT),
+    status: z.nativeEnum(AVATAR_STUDIO_JOB_STATUS),
+    request: JsonObjectSchema.nullable(),
+    resultMediaId: z.string().uuid().nullable(),
+    tokenReservationUuid: z.string().uuid().nullable(),
+    price: z.number().nullable(),
+    error: z.string().nullable(),
+    resultMedia: AvatarStudioMediaSchema.nullable().optional(),
+    startedAt: z.date().nullable(),
+    completedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export const AvatarStudioGenerationJobSchema = AvatarStudioGenerationJobBaseSchema.extend({
+    children: z.array(AvatarStudioGenerationJobBaseSchema).optional(),
+});
+export type AvatarStudioGenerationJob = z.infer<typeof AvatarStudioGenerationJobSchema>;
+
+export const AvatarStudioExportJobSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    clipId: z.string().uuid(),
+    status: z.nativeEnum(AVATAR_STUDIO_EXPORT_STATUS),
+    resultMediaId: z.string().uuid().nullable(),
+    error: z.string().nullable(),
+    request: JsonObjectSchema.nullable(),
+    resultMedia: AvatarStudioMediaSchema.nullable().optional(),
+    startedAt: z.date().nullable(),
+    completedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type AvatarStudioExportJob = z.infer<typeof AvatarStudioExportJobSchema>;
+
+export const AvatarStudioScriptwriterMessageSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    clipId: z.string().uuid(),
+    sceneId: z.string().uuid().nullable(),
+    role: z.nativeEnum(AVATAR_STUDIO_SCRIPTWRITER_ROLE),
+    content: z.string(),
+    tokenReservationUuid: z.string().uuid().nullable(),
+    price: z.number().nullable(),
+    metadata: JsonObjectSchema.nullable(),
+    createdAt: z.date(),
+});
+export type AvatarStudioScriptwriterMessage = z.infer<typeof AvatarStudioScriptwriterMessageSchema>;
+
+export const AvatarStudioClipSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    title: z.string(),
+    subtitleSettings: AvatarStudioSubtitleSettingsSchema,
+    selectedVoiceId: z.string().uuid().nullable(),
+    exportMediaId: z.string().uuid().nullable(),
+    selectedVoice: AvatarStudioVoiceSchema.nullable().optional(),
+    exportMedia: AvatarStudioMediaSchema.nullable().optional(),
+    scenes: z.array(AvatarStudioSceneSchema).optional(),
+    media: z.array(AvatarStudioMediaSchema).optional(),
+    voices: z.array(AvatarStudioVoiceSchema).optional(),
+    generationJobs: z.array(AvatarStudioGenerationJobSchema).optional(),
+    exportJobs: z.array(AvatarStudioExportJobSchema).optional(),
+    scriptwriterMessages: z.array(AvatarStudioScriptwriterMessageSchema).optional(),
+    deletedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type AvatarStudioClip = z.infer<typeof AvatarStudioClipSchema>;

package/models/avatar-studio/index.ts

@@ -0,0 +1 @@
+export * from './avatar-studio.schema';

package/models/canvas-node.schema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CANVAS_NODE_TYPE, NODE_RUN_STATUS } from '../constants';
+import { CANVAS_NODE_ERROR_KIND, CANVAS_NODE_TYPE, NODE_RUN_STATUS } from '../constants';
 
 const strictObject = <T extends z.ZodRawShape>(shape: T): z.ZodObject<T, 'strict'> =>
     z.object(shape).strict();
@@ -226,10 +226,17 @@ export const CanvasNodeOutputSchemaByType = {
     [CANVAS_NODE_TYPE.audioBlock]: AudioBlockOutputSchema,
 } as const;
 
+export const CanvasNodeErrorDetailsSchema = z
+    .object({
+        nodeId: z.string().uuid().optional(),
+        errorKind: z.nativeEnum(CANVAS_NODE_ERROR_KIND).optional(),
+    })
+    .catchall(z.unknown());
+
 export const CanvasNodeErrorSchema = z.object({
     code: z.string(),
     message: z.string(),
-    details: z.record(z.unknown()).optional(),
+    details: CanvasNodeErrorDetailsSchema.optional(),
     retryable: z.boolean().optional(),
 });
 export type CanvasNodeError = z.infer<typeof CanvasNodeErrorSchema>;

package/models/file.schema.ts

@@ -18,7 +18,7 @@ export const FileSchema = z.object({
     key: z.string(),
     type: z.nativeEnum(FILE_TYPE),
     duration: z.number().nullable(),
-    attachmentCost: z.number(),
+    attachmentCost: z.number().default(0),
     contentLength: z.number().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),

package/models/index.ts

@@ -4,6 +4,7 @@ export * from './ai-model-config.schema';
 export * from './ai-model-formatted.schema';
 export * from './ai-model.schema';
 export * from './ai-vendor.schema';
+export * from './avatar-studio';
 export * from './canvas.schema';
 export * from './canvas-node-definition.schema';
 export * from './canvas-node.schema';

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

@@ -9,6 +9,8 @@ export const VideoJobParamsSchema = z.object({
     referenceImageIds: z.array(z.string()).optional(),
     firstFrameUrl: z.string().optional(),
     lastFrameUrl: z.string().optional(),
+    audioUrl: z.string().url().optional(),
+    audioId: z.string().uuid().optional(),
     firstFrameId: z.string().optional(),
     lastFrameId: z.string().optional(),
     duration: z.number().optional(),

package/models/tools/video/video-model.schema.ts

@@ -34,6 +34,12 @@ export const VideoModelParamsSchema = z.object({
             options: z.array(z.boolean()),
         })
         .optional(),
+    audioAttachment: z
+        .object({
+            supported: z.boolean(),
+            maxAudioUrls: z.number(),
+        })
+        .optional(),
     multiShots: z
         .object({
             options: z.array(z.boolean()),
@@ -52,6 +58,7 @@ export const VideoGenerationRequestParamsSchema = z.object({
     referenceImages: z.string().uuid().array().optional(),
     firstFrameImageId: z.string().uuid().optional(),
     lastFrameImageId: z.string().uuid().optional(),
+    audioId: z.string().uuid().optional(),
     duration: z.number(),
     aspectRatio: z.string().optional(),
     quality: z.string().optional(),
@@ -64,6 +71,8 @@ export type VideoGenerationRequestParams = z.infer<typeof VideoGenerationRequest
 
 export const VideoModelPricingRuleConditionSchema = z.object({
     aspectRatio: z.string().optional(),
+    duration: z.number().optional(),
+    quality: z.string().optional(),
     resolution: z.string().optional(),
     sound: z.boolean().optional(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.14.11",
+  "version": "0.14.13-avatar-studio",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",